//////////////////////////////////////////////////////////////////////////////
//
//  File:       _win32.cpp
//  Source:     win32.cpp
//
//  Copyright:  1996-2001, Microsoft Corporation
//

///////////////////////////////////////////////////////////////// Trampolines.
//

#pragma warning(disable:4100)   // Trampolines don't use formal parameters.

DETOUR_TRAMPOLINE(int __stdcall Real_AbortDoc(HDC a0),
                  AbortDoc);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_AbortPath(HDC a0),
                  AbortPath);

DETOUR_TRAMPOLINE(HKL __stdcall Real_ActivateKeyboardLayout(HKL a0,
                                                            UINT a1),
                  ActivateKeyboardLayout);

DETOUR_TRAMPOLINE(ATOM __stdcall Real_AddAtomA(LPCSTR a0),
                  AddAtomA);

DETOUR_TRAMPOLINE(ATOM __stdcall Real_AddAtomW(LPCWSTR a0),
                  AddAtomW);

DETOUR_TRAMPOLINE(int __stdcall Real_AddFontResourceA(LPCSTR a0),
                  AddFontResourceA);

DETOUR_TRAMPOLINE(int __stdcall Real_AddFontResourceW(LPCWSTR a0),
                  AddFontResourceW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_AdjustWindowRect(LPRECT a0,
                                                       DWORD a1,
                                                       BOOL a2),
                  AdjustWindowRect);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_AdjustWindowRectEx(LPRECT a0,
                                                         DWORD a1,
                                                         BOOL a2,
                                                         DWORD a3),
                  AdjustWindowRectEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_AllocConsole(void),
                  AllocConsole);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_AngleArc(HDC a0,
                                               int a1,
                                               int a2,
                                               DWORD a3,
                                               FLOAT a4,
                                               FLOAT a5),
                  AngleArc);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_AnimatePalette(HPALETTE a0,
                                                     UINT a1,
                                                     UINT a2,
                                                     PALETTEENTRY* a3),
                  AnimatePalette);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_AnyPopup(void),
                  AnyPopup);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_AppendMenuA(HMENU a0,
                                                  UINT a1,
                                                  UINT_PTR a2,
                                                  LPCSTR a3),
                  AppendMenuA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_AppendMenuW(HMENU a0,
                                                  UINT a1,
                                                  UINT_PTR a2,
                                                  LPCWSTR a3),
                  AppendMenuW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_Arc(HDC a0,
                                          int a1,
                                          int a2,
                                          int a3,
                                          int a4,
                                          int a5,
                                          int a6,
                                          int a7,
                                          int a8),
                  Arc);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ArcTo(HDC a0,
                                            int a1,
                                            int a2,
                                            int a3,
                                            int a4,
                                            int a5,
                                            int a6,
                                            int a7,
                                            int a8),
                  ArcTo);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_AreFileApisANSI(void),
                  AreFileApisANSI);

DETOUR_TRAMPOLINE(UINT __stdcall Real_ArrangeIconicWindows(HWND a0),
                  ArrangeIconicWindows);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_AttachThreadInput(DWORD a0,
                                                        DWORD a1,
                                                        BOOL a2),
                  AttachThreadInput);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_BackupRead(HANDLE a0,
                                                 LPBYTE a1,
                                                 DWORD a2,
                                                 LPDWORD a3,
                                                 BOOL a4,
                                                 BOOL a5,
                                                 LPVOID* a6),
                  BackupRead);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_BackupSeek(HANDLE a0,
                                                 DWORD a1,
                                                 DWORD a2,
                                                 LPDWORD a3,
                                                 LPDWORD a4,
                                                 LPVOID* a5),
                  BackupSeek);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_BackupWrite(HANDLE a0,
                                                  LPBYTE a1,
                                                  DWORD a2,
                                                  LPDWORD a3,
                                                  BOOL a4,
                                                  BOOL a5,
                                                  LPVOID* a6),
                  BackupWrite);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_Beep(DWORD a0,
                                           DWORD a1),
                  Beep);

DETOUR_TRAMPOLINE(HDWP __stdcall Real_BeginDeferWindowPos(int a0),
                  BeginDeferWindowPos);

DETOUR_TRAMPOLINE(HDC __stdcall Real_BeginPaint(HWND a0,
                                                LPPAINTSTRUCT a1),
                  BeginPaint);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_BeginPath(HDC a0),
                  BeginPath);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_BeginUpdateResourceA(LPCSTR a0,
                                                             BOOL a1),
                  BeginUpdateResourceA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_BeginUpdateResourceW(LPCWSTR a0,
                                                             BOOL a1),
                  BeginUpdateResourceW);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_BindMoniker(struct IMoniker* a0,
                                                     DWORD a1,
                                                     IID& a2,
                                                     LPVOID* a3),
                  BindMoniker);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_BitBlt(HDC a0,
                                             int a1,
                                             int a2,
                                             int a3,
                                             int a4,
                                             HDC a5,
                                             int a6,
                                             int a7,
                                             DWORD a8),
                  BitBlt);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_BringWindowToTop(HWND a0),
                  BringWindowToTop);

DETOUR_TRAMPOLINE(long __stdcall Real_BroadcastSystemMessageA(DWORD a0,
                                                              LPDWORD a1,
                                                              UINT a2,
                                                              WPARAM a3,
                                                              LPARAM a4),
                  BroadcastSystemMessageA);

DETOUR_TRAMPOLINE(long __stdcall Real_BroadcastSystemMessageW(DWORD a0,
                                                              LPDWORD a1,
                                                              UINT a2,
                                                              WPARAM a3,
                                                              LPARAM a4),
                  BroadcastSystemMessageW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_BuildCommDCBA(LPCSTR a0,
                                                    struct _DCB* a1),
                  BuildCommDCBA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_BuildCommDCBAndTimeoutsA(LPCSTR a0,
                                                               struct _DCB* a1,
                                                               struct _COMMTIMEOUTS* a2),
                  BuildCommDCBAndTimeoutsA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_BuildCommDCBAndTimeoutsW(LPCWSTR a0,
                                                               struct _DCB* a1,
                                                               struct _COMMTIMEOUTS* a2),
                  BuildCommDCBAndTimeoutsW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_BuildCommDCBW(LPCWSTR a0,
                                                    struct _DCB* a1),
                  BuildCommDCBW);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CLSIDFromProgID(LPCOLESTR a0,
                                                         struct _GUID* a1),
                  CLSIDFromProgID);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CLSIDFromString(LPOLESTR a0,
                                                         struct _GUID* a1),
                  CLSIDFromString);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CallMsgFilterA(LPMSG a0,
                                                     int a1),
                  CallMsgFilterA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CallMsgFilterW(LPMSG a0,
                                                     int a1),
                  CallMsgFilterW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CallNamedPipeA(LPCSTR a0,
                                                     LPVOID a1,
                                                     DWORD a2,
                                                     LPVOID a3,
                                                     DWORD a4,
                                                     LPDWORD a5,
                                                     DWORD a6),
                  CallNamedPipeA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CallNamedPipeW(LPCWSTR a0,
                                                     LPVOID a1,
                                                     DWORD a2,
                                                     LPVOID a3,
                                                     DWORD a4,
                                                     LPDWORD a5,
                                                     DWORD a6),
                  CallNamedPipeW);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_CallNextHookEx(HHOOK a0,
                                                        int a1,
                                                        WPARAM a2,
                                                        LPARAM a3),
                  CallNextHookEx);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_CallWindowProcA(WNDPROC a0,
                                                         HWND a1,
                                                         UINT a2,
                                                         WPARAM a3,
                                                         LPARAM a4),
                  CallWindowProcA);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_CallWindowProcW(WNDPROC a0,
                                                         HWND a1,
                                                         UINT a2,
                                                         WPARAM a3,
                                                         LPARAM a4),
                  CallWindowProcW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CancelDC(HDC a0),
                  CancelDC);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CancelIo(HANDLE a0),
                  CancelIo);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CancelWaitableTimer(HANDLE a0),
                  CancelWaitableTimer);

DETOUR_TRAMPOLINE(WORD __stdcall Real_CascadeWindows(HWND a0,
                                                     UINT a1,
                                                     RECT* a2,
                                                     UINT a3,
                                                     struct HWND__** a4),
                  CascadeWindows);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ChangeClipboardChain(HWND a0,
                                                           HWND a1),
                  ChangeClipboardChain);

DETOUR_TRAMPOLINE(LONG __stdcall Real_ChangeDisplaySettingsA(LPDEVMODEA a0,
                                                             DWORD a1),
                  ChangeDisplaySettingsA);

DETOUR_TRAMPOLINE(LONG __stdcall Real_ChangeDisplaySettingsExA(LPCSTR a0,
                                                               LPDEVMODEA a1,
                                                               HWND a2,
                                                               DWORD a3,
                                                               LPVOID a4),
                  ChangeDisplaySettingsExA);

DETOUR_TRAMPOLINE(LONG __stdcall Real_ChangeDisplaySettingsExW(LPCWSTR a0,
                                                               LPDEVMODEW a1,
                                                               HWND a2,
                                                               DWORD a3,
                                                               LPVOID a4),
                  ChangeDisplaySettingsExW);

DETOUR_TRAMPOLINE(LONG __stdcall Real_ChangeDisplaySettingsW(LPDEVMODEW a0,
                                                             DWORD a1),
                  ChangeDisplaySettingsW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ChangeMenuA(HMENU a0,
                                                  UINT a1,
                                                  LPCSTR a2,
                                                  UINT a3,
                                                  UINT a4),
                  ChangeMenuA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ChangeMenuW(HMENU a0,
                                                  UINT a1,
                                                  LPCWSTR a2,
                                                  UINT a3,
                                                  UINT a4),
                  ChangeMenuW);

DETOUR_TRAMPOLINE(LPSTR __stdcall Real_CharLowerA(LPSTR a0),
                  CharLowerA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_CharLowerBuffA(LPSTR a0,
                                                      DWORD a1),
                  CharLowerBuffA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_CharLowerBuffW(LPWSTR a0,
                                                      DWORD a1),
                  CharLowerBuffW);

DETOUR_TRAMPOLINE(LPWSTR __stdcall Real_CharLowerW(LPWSTR a0),
                  CharLowerW);

DETOUR_TRAMPOLINE(LPSTR __stdcall Real_CharNextA(LPCSTR a0),
                  CharNextA);

DETOUR_TRAMPOLINE(LPSTR __stdcall Real_CharNextExA(WORD a0,
                                                   LPCSTR a1,
                                                   DWORD a2),
                  CharNextExA);

DETOUR_TRAMPOLINE(LPWSTR __stdcall Real_CharNextW(LPCWSTR a0),
                  CharNextW);

DETOUR_TRAMPOLINE(LPSTR __stdcall Real_CharPrevA(LPCSTR a0,
                                                 LPCSTR a1),
                  CharPrevA);

DETOUR_TRAMPOLINE(LPSTR __stdcall Real_CharPrevExA(WORD a0,
                                                   LPCSTR a1,
                                                   LPCSTR a2,
                                                   DWORD a3),
                  CharPrevExA);

DETOUR_TRAMPOLINE(LPWSTR __stdcall Real_CharPrevW(LPCWSTR a0,
                                                  LPCWSTR a1),
                  CharPrevW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CharToOemA(LPCSTR a0,
                                                 LPSTR a1),
                  CharToOemA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CharToOemBuffA(LPCSTR a0,
                                                     LPSTR a1,
                                                     DWORD a2),
                  CharToOemBuffA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CharToOemBuffW(LPCWSTR a0,
                                                     LPSTR a1,
                                                     DWORD a2),
                  CharToOemBuffW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CharToOemW(LPCWSTR a0,
                                                 LPSTR a1),
                  CharToOemW);

DETOUR_TRAMPOLINE(LPSTR __stdcall Real_CharUpperA(LPSTR a0),
                  CharUpperA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_CharUpperBuffA(LPSTR a0,
                                                      DWORD a1),
                  CharUpperBuffA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_CharUpperBuffW(LPWSTR a0,
                                                      DWORD a1),
                  CharUpperBuffW);

DETOUR_TRAMPOLINE(LPWSTR __stdcall Real_CharUpperW(LPWSTR a0),
                  CharUpperW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CheckColorsInGamut(HDC a0,
                                                         LPVOID a1,
                                                         LPVOID a2,
                                                         DWORD a3),
                  CheckColorsInGamut);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CheckDlgButton(HWND a0,
                                                     int a1,
                                                     UINT a2),
                  CheckDlgButton);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_CheckMenuItem(HMENU a0,
                                                     UINT a1,
                                                     UINT a2),
                  CheckMenuItem);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CheckMenuRadioItem(HMENU a0,
                                                         UINT a1,
                                                         UINT a2,
                                                         UINT a3,
                                                         UINT a4),
                  CheckMenuRadioItem);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CheckRadioButton(HWND a0,
                                                       int a1,
                                                       int a2,
                                                       int a3),
                  CheckRadioButton);

DETOUR_TRAMPOLINE(HWND __stdcall Real_ChildWindowFromPoint(HWND a0,
                                                           POINT a1),
                  ChildWindowFromPoint);

DETOUR_TRAMPOLINE(HWND __stdcall Real_ChildWindowFromPointEx(HWND a0,
                                                             POINT a1,
                                                             UINT a2),
                  ChildWindowFromPointEx);

DETOUR_TRAMPOLINE(int __stdcall Real_ChoosePixelFormat(HDC a0,
                                                       PIXELFORMATDESCRIPTOR* a1),
                  ChoosePixelFormat);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_Chord(HDC a0,
                                            int a1,
                                            int a2,
                                            int a3,
                                            int a4,
                                            int a5,
                                            int a6,
                                            int a7,
                                            int a8),
                  Chord);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ClearCommBreak(HANDLE a0),
                  ClearCommBreak);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ClearCommError(HANDLE a0,
                                                     LPDWORD a1,
                                                     struct _COMSTAT* a2),
                  ClearCommError);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ClientToScreen(HWND a0,
                                                     struct tagPOINT* a1),
                  ClientToScreen);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ClipCursor(RECT* a0),
                  ClipCursor);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CloseClipboard(void),
                  CloseClipboard);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CloseDesktop(HDESK a0),
                  CloseDesktop);

DETOUR_TRAMPOLINE(HENHMETAFILE __stdcall Real_CloseEnhMetaFile(HDC a0),
                  CloseEnhMetaFile);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CloseFigure(HDC a0),
                  CloseFigure);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CloseHandle(HANDLE a0),
                  CloseHandle);

DETOUR_TRAMPOLINE(HMETAFILE __stdcall Real_CloseMetaFile(HDC a0),
                  CloseMetaFile);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CloseWindow(HWND a0),
                  CloseWindow);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CloseWindowStation(HWINSTA a0),
                  CloseWindowStation);

DETOUR_TRAMPOLINE(ULONG __stdcall Real_CoAddRefServerProcess(void),
                  CoAddRefServerProcess);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_CoBuildVersion(void),
                  CoBuildVersion);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoCopyProxy(IUnknown* a0,
                                                     IUnknown** a1),
                  CoCopyProxy);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoCreateFreeThreadedMarshaler(LPUNKNOWN a0,
                                                                       LPUNKNOWN* a1),
                  CoCreateFreeThreadedMarshaler);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoCreateGuid(GUID* a0),
                  CoCreateGuid);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoCreateInstance(IID& a0,
                                                          LPUNKNOWN a1,
                                                          DWORD a2,
                                                          IID& a3,
                                                          LPVOID* a4),
                  CoCreateInstance);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoCreateInstanceEx(IID& a0,
                                                            IUnknown* a1,
                                                            DWORD a2,
                                                            COSERVERINFO* a3,
                                                            DWORD a4,
                                                            struct tagMULTI_QI* a5),
                  CoCreateInstanceEx);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoDisconnectObject(LPUNKNOWN a0,
                                                            DWORD a1),
                  CoDisconnectObject);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CoDosDateTimeToFileTime(WORD a0,
                                                              WORD a1,
                                                              FILETIME* a2),
                  CoDosDateTimeToFileTime);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoFileTimeNow(FILETIME* a0),
                  CoFileTimeNow);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CoFileTimeToDosDateTime(FILETIME* a0,
                                                              LPWORD a1,
                                                              LPWORD a2),
                  CoFileTimeToDosDateTime);

DETOUR_TRAMPOLINE(void __stdcall Real_CoFreeAllLibraries(void),
                  CoFreeAllLibraries);

DETOUR_TRAMPOLINE(void __stdcall Real_CoFreeLibrary(HINSTANCE a0),
                  CoFreeLibrary);

DETOUR_TRAMPOLINE(void __stdcall Real_CoFreeUnusedLibraries(void),
                  CoFreeUnusedLibraries);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoGetCallContext(IID& a0,
                                                          void** a1),
                  CoGetCallContext);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoGetClassObject(IID& a0,
                                                          DWORD a1,
                                                          LPVOID a2,
                                                          IID& a3,
                                                          LPVOID* a4),
                  CoGetClassObject);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_CoGetCurrentProcess(void),
                  CoGetCurrentProcess);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoGetInstanceFromFile(COSERVERINFO* a0,
                                                               CLSID* a1,
                                                               IUnknown* a2,
                                                               DWORD a3,
                                                               DWORD a4,
                                                               OLECHAR* a5,
                                                               DWORD a6,
                                                               struct tagMULTI_QI* a7),
                  CoGetInstanceFromFile);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoGetInstanceFromIStorage(COSERVERINFO* a0,
                                                                   CLSID* a1,
                                                                   IUnknown* a2,
                                                                   DWORD a3,
                                                                   IStorage* a4,
                                                                   DWORD a5,
                                                                   struct tagMULTI_QI* a6),
                  CoGetInstanceFromIStorage);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoGetInterfaceAndReleaseStream(LPSTREAM a0,
                                                                        IID& a1,
                                                                        LPVOID* a2),
                  CoGetInterfaceAndReleaseStream);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoGetMalloc(DWORD a0,
                                                     struct IMalloc** a1),
                  CoGetMalloc);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoGetMarshalSizeMax(ULONG* a0,
                                                             IID& a1,
                                                             LPUNKNOWN a2,
                                                             DWORD a3,
                                                             LPVOID a4,
                                                             DWORD a5),
                  CoGetMarshalSizeMax);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoGetObject(LPCWSTR a0,
                                                     BIND_OPTS* a1,
                                                     IID& a2,
                                                     void** a3),
                  CoGetObject);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoGetPSClsid(IID& a0,
                                                      CLSID* a1),
                  CoGetPSClsid);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoGetStandardMarshal(IID& a0,
                                                              LPUNKNOWN a1,
                                                              DWORD a2,
                                                              LPVOID a3,
                                                              DWORD a4,
                                                              struct IMarshal** a5),
                  CoGetStandardMarshal);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoGetStdMarshalEx(LPUNKNOWN a0,
                                                           DWORD a1,
                                                           LPUNKNOWN* a2),
                  CoGetStdMarshalEx);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoGetTreatAsClass(IID& a0,
                                                           struct _GUID* a1),
                  CoGetTreatAsClass);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoImpersonateClient(void),
                  CoImpersonateClient);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoInitialize(LPVOID a0),
                  CoInitialize);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoInitializeEx(LPVOID a0,
                                                        DWORD a1),
                  CoInitializeEx);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoInitializeSecurity(PSECURITY_DESCRIPTOR a0,
                                                              LONG a1,
                                                              struct tagSOLE_AUTHENTICATION_SERVICE* a2,
                                                              void* a3,
                                                              DWORD a4,
                                                              DWORD a5,
                                                              void* a6,
                                                              DWORD a7,
                                                              void* a8),
                  CoInitializeSecurity);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoInstall(IBindCtx* a0,
                                                   DWORD a1,
                                                   uCLSSPEC* a2,
                                                   struct tagQUERYCONTEXT* a3,
                                                   LPWSTR a4),
                  CoInstall);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CoIsHandlerConnected(LPUNKNOWN a0),
                  CoIsHandlerConnected);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CoIsOle1Class(IID& a0),
                  CoIsOle1Class);

DETOUR_TRAMPOLINE(HINSTANCE __stdcall Real_CoLoadLibrary(LPOLESTR a0,
                                                         BOOL a1),
                  CoLoadLibrary);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoLockObjectExternal(LPUNKNOWN a0,
                                                              BOOL a1,
                                                              BOOL a2),
                  CoLockObjectExternal);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoMarshalHresult(LPSTREAM a0,
                                                          HRESULT a1),
                  CoMarshalHresult);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoMarshalInterThreadInterfaceInStream(IID& a0,
                                                                               LPUNKNOWN a1,
                                                                               LPSTREAM* a2),
                  CoMarshalInterThreadInterfaceInStream);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoMarshalInterface(LPSTREAM a0,
                                                            IID& a1,
                                                            LPUNKNOWN a2,
                                                            DWORD a3,
                                                            LPVOID a4,
                                                            DWORD a5),
                  CoMarshalInterface);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoQueryAuthenticationServices(DWORD* a0,
                                                                       struct tagSOLE_AUTHENTICATION_SERVICE** a1),
                  CoQueryAuthenticationServices);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoQueryClientBlanket(DWORD* a0,
                                                              DWORD* a1,
                                                              OLECHAR** a2,
                                                              DWORD* a3,
                                                              DWORD* a4,
                                                              RPC_AUTHZ_HANDLE* a5,
                                                              DWORD* a6),
                  CoQueryClientBlanket);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoQueryProxyBlanket(IUnknown* a0,
                                                             DWORD* a1,
                                                             DWORD* a2,
                                                             OLECHAR** a3,
                                                             DWORD* a4,
                                                             DWORD* a5,
                                                             RPC_AUTH_IDENTITY_HANDLE* a6,
                                                             DWORD* a7),
                  CoQueryProxyBlanket);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoRegisterChannelHook(GUID& a0,
                                                               IChannelHook* a1),
                  CoRegisterChannelHook);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoRegisterClassObject(IID& a0,
                                                               LPUNKNOWN a1,
                                                               DWORD a2,
                                                               DWORD a3,
                                                               LPDWORD a4),
                  CoRegisterClassObject);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoRegisterMallocSpy(struct IMallocSpy* a0),
                  CoRegisterMallocSpy);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoRegisterMessageFilter(LPMESSAGEFILTER a0,
                                                                 LPMESSAGEFILTER* a1),
                  CoRegisterMessageFilter);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoRegisterPSClsid(IID& a0,
                                                           IID& a1),
                  CoRegisterPSClsid);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoRegisterSurrogate(LPSURROGATE a0),
                  CoRegisterSurrogate);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoReleaseMarshalData(LPSTREAM a0),
                  CoReleaseMarshalData);

DETOUR_TRAMPOLINE(ULONG __stdcall Real_CoReleaseServerProcess(void),
                  CoReleaseServerProcess);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoResumeClassObjects(void),
                  CoResumeClassObjects);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoRevertToSelf(void),
                  CoRevertToSelf);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoRevokeClassObject(DWORD a0),
                  CoRevokeClassObject);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoRevokeMallocSpy(void),
                  CoRevokeMallocSpy);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoSetProxyBlanket(IUnknown* a0,
                                                           DWORD a1,
                                                           DWORD a2,
                                                           OLECHAR* a3,
                                                           DWORD a4,
                                                           DWORD a5,
                                                           RPC_AUTH_IDENTITY_HANDLE a6,
                                                           DWORD a7),
                  CoSetProxyBlanket);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoSuspendClassObjects(void),
                  CoSuspendClassObjects);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoSwitchCallContext(IUnknown* a0,
                                                             IUnknown** a1),
                  CoSwitchCallContext);

DETOUR_TRAMPOLINE(LPVOID __stdcall Real_CoTaskMemAlloc(ULONG a0),
                  CoTaskMemAlloc);

DETOUR_TRAMPOLINE(void __stdcall Real_CoTaskMemFree(LPVOID a0),
                  CoTaskMemFree);

DETOUR_TRAMPOLINE(LPVOID __stdcall Real_CoTaskMemRealloc(LPVOID a0,
                                                         ULONG a1),
                  CoTaskMemRealloc);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoTreatAsClass(IID& a0,
                                                        IID& a1),
                  CoTreatAsClass);

DETOUR_TRAMPOLINE(void __stdcall Real_CoUninitialize(void),
                  CoUninitialize);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoUnmarshalHresult(LPSTREAM a0,
                                                            HRESULT* a1),
                  CoUnmarshalHresult);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CoUnmarshalInterface(LPSTREAM a0,
                                                              IID& a1,
                                                              LPVOID* a2),
                  CoUnmarshalInterface);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ColorMatchToTarget(HDC a0,
                                                         HDC a1,
                                                         DWORD a2),
                  ColorMatchToTarget);

DETOUR_TRAMPOLINE(int __stdcall Real_CombineRgn(HRGN a0,
                                                HRGN a1,
                                                HRGN a2,
                                                int a3),
                  CombineRgn);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CombineTransform(struct tagXFORM* a0,
                                                       XFORM* a1,
                                                       XFORM* a2),
                  CombineTransform);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CommConfigDialogA(LPCSTR a0,
                                                        HWND a1,
                                                        LPCOMMCONFIG a2),
                  CommConfigDialogA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CommConfigDialogW(LPCWSTR a0,
                                                        HWND a1,
                                                        LPCOMMCONFIG a2),
                  CommConfigDialogW);

DETOUR_TRAMPOLINE(LONG __stdcall Real_CompareFileTime(FILETIME* a0,
                                                      FILETIME* a1),
                  CompareFileTime);

DETOUR_TRAMPOLINE(int __stdcall Real_CompareStringA(LCID a0,
                                                    DWORD a1,
                                                    LPCSTR a2,
                                                    int a3,
                                                    LPCSTR a4,
                                                    int a5),
                  CompareStringA);

DETOUR_TRAMPOLINE(int __stdcall Real_CompareStringW(LCID a0,
                                                    DWORD a1,
                                                    LPCWSTR a2,
                                                    int a3,
                                                    LPCWSTR a4,
                                                    int a5),
                  CompareStringW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ConnectNamedPipe(HANDLE a0,
                                                       LPOVERLAPPED a1),
                  ConnectNamedPipe);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ContinueDebugEvent(DWORD a0,
                                                         DWORD a1,
                                                         DWORD a2),
                  ContinueDebugEvent);

DETOUR_TRAMPOLINE(LCID __stdcall Real_ConvertDefaultLocale(LCID a0),
                  ConvertDefaultLocale);

DETOUR_TRAMPOLINE(LPVOID __stdcall Real_ConvertThreadToFiber(LPVOID a0),
                  ConvertThreadToFiber);

DETOUR_TRAMPOLINE(int __stdcall Real_CopyAcceleratorTableA(HACCEL a0,
                                                           struct tagACCEL* a1,
                                                           int a2),
                  CopyAcceleratorTableA);

DETOUR_TRAMPOLINE(int __stdcall Real_CopyAcceleratorTableW(HACCEL a0,
                                                           struct tagACCEL* a1,
                                                           int a2),
                  CopyAcceleratorTableW);

DETOUR_TRAMPOLINE(HENHMETAFILE __stdcall Real_CopyEnhMetaFileA(HENHMETAFILE a0,
                                                               LPCSTR a1),
                  CopyEnhMetaFileA);

DETOUR_TRAMPOLINE(HENHMETAFILE __stdcall Real_CopyEnhMetaFileW(HENHMETAFILE a0,
                                                               LPCWSTR a1),
                  CopyEnhMetaFileW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CopyFileA(LPCSTR a0,
                                                LPCSTR a1,
                                                BOOL a2),
                  CopyFileA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CopyFileExA(LPCSTR a0,
                                                  LPCSTR a1,
                                                  LPPROGRESS_ROUTINE a2,
                                                  LPVOID a3,
                                                  LPBOOL a4,
                                                  DWORD a5),
                  CopyFileExA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CopyFileExW(LPCWSTR a0,
                                                  LPCWSTR a1,
                                                  LPPROGRESS_ROUTINE a2,
                                                  LPVOID a3,
                                                  LPBOOL a4,
                                                  DWORD a5),
                  CopyFileExW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CopyFileW(LPCWSTR a0,
                                                LPCWSTR a1,
                                                BOOL a2),
                  CopyFileW);

DETOUR_TRAMPOLINE(HICON __stdcall Real_CopyIcon(HICON a0),
                  CopyIcon);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_CopyImage(HANDLE a0,
                                                  UINT a1,
                                                  int a2,
                                                  int a3,
                                                  UINT a4),
                  CopyImage);

DETOUR_TRAMPOLINE(HMETAFILE __stdcall Real_CopyMetaFileA(HMETAFILE a0,
                                                         LPCSTR a1),
                  CopyMetaFileA);

DETOUR_TRAMPOLINE(HMETAFILE __stdcall Real_CopyMetaFileW(HMETAFILE a0,
                                                         LPCWSTR a1),
                  CopyMetaFileW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CopyRect(LPRECT a0,
                                               RECT* a1),
                  CopyRect);

DETOUR_TRAMPOLINE(int __stdcall Real_CountClipboardFormats(void),
                  CountClipboardFormats);

DETOUR_TRAMPOLINE(HACCEL __stdcall Real_CreateAcceleratorTableA(struct tagACCEL* a0,
                                                                int a1),
                  CreateAcceleratorTableA);

DETOUR_TRAMPOLINE(HACCEL __stdcall Real_CreateAcceleratorTableW(struct tagACCEL* a0,
                                                                int a1),
                  CreateAcceleratorTableW);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CreateAntiMoniker(struct IMoniker** a0),
                  CreateAntiMoniker);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CreateBindCtx(DWORD a0,
                                                       struct IBindCtx** a1),
                  CreateBindCtx);

DETOUR_TRAMPOLINE(HBITMAP __stdcall Real_CreateBitmap(int a0,
                                                      int a1,
                                                      UINT a2,
                                                      UINT a3,
                                                      void* a4),
                  CreateBitmap);

DETOUR_TRAMPOLINE(HBITMAP __stdcall Real_CreateBitmapIndirect(BITMAP* a0),
                  CreateBitmapIndirect);

DETOUR_TRAMPOLINE(HBRUSH __stdcall Real_CreateBrushIndirect(struct tagLOGBRUSH* a0),
                  CreateBrushIndirect);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CreateCaret(HWND a0,
                                                  HBITMAP a1,
                                                  int a2,
                                                  int a3),
                  CreateCaret);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CreateClassMoniker(IID& a0,
                                                            struct IMoniker** a1),
                  CreateClassMoniker);

DETOUR_TRAMPOLINE(HCOLORSPACE __stdcall Real_CreateColorSpaceA(struct tagLOGCOLORSPACEA* a0),
                  CreateColorSpaceA);

DETOUR_TRAMPOLINE(HCOLORSPACE __stdcall Real_CreateColorSpaceW(struct tagLOGCOLORSPACEW* a0),
                  CreateColorSpaceW);

DETOUR_TRAMPOLINE(HBITMAP __stdcall Real_CreateCompatibleBitmap(HDC a0,
                                                                int a1,
                                                                int a2),
                  CreateCompatibleBitmap);

DETOUR_TRAMPOLINE(HDC __stdcall Real_CreateCompatibleDC(HDC a0),
                  CreateCompatibleDC);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_CreateConsoleScreenBuffer(DWORD a0,
                                                                  DWORD a1,
                                                                  SECURITY_ATTRIBUTES* a2,
                                                                  DWORD a3,
                                                                  LPVOID a4),
                  CreateConsoleScreenBuffer);

DETOUR_TRAMPOLINE(HCURSOR __stdcall Real_CreateCursor(HINSTANCE a0,
                                                      int a1,
                                                      int a2,
                                                      int a3,
                                                      int a4,
                                                      void* a5,
                                                      void* a6),
                  CreateCursor);

DETOUR_TRAMPOLINE(HDC __stdcall Real_CreateDCA(LPCSTR a0,
                                               LPCSTR a1,
                                               LPCSTR a2,
                                               struct _devicemodeA* a3),
                  CreateDCA);

DETOUR_TRAMPOLINE(HDC __stdcall Real_CreateDCW(LPCWSTR a0,
                                               LPCWSTR a1,
                                               LPCWSTR a2,
                                               struct _devicemodeW* a3),
                  CreateDCW);

DETOUR_TRAMPOLINE(HBRUSH __stdcall Real_CreateDIBPatternBrush(HGLOBAL a0,
                                                              UINT a1),
                  CreateDIBPatternBrush);

DETOUR_TRAMPOLINE(HBRUSH __stdcall Real_CreateDIBPatternBrushPt(void* a0,
                                                                UINT a1),
                  CreateDIBPatternBrushPt);

DETOUR_TRAMPOLINE(HBITMAP __stdcall Real_CreateDIBSection(HDC a0,
                                                          struct tagBITMAPINFO* a1,
                                                          UINT a2,
                                                          void** a3,
                                                          HANDLE a4,
                                                          DWORD a5),
                  CreateDIBSection);

DETOUR_TRAMPOLINE(HBITMAP __stdcall Real_CreateDIBitmap(HDC a0,
                                                        BITMAPINFOHEADER* a1,
                                                        DWORD a2,
                                                        void* a3,
                                                        struct tagBITMAPINFO* a4,
                                                        UINT a5),
                  CreateDIBitmap);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CreateDataAdviseHolder(LPDATAADVISEHOLDER* a0),
                  CreateDataAdviseHolder);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CreateDataCache(LPUNKNOWN a0,
                                                         IID& a1,
                                                         IID& a2,
                                                         LPVOID* a3),
                  CreateDataCache);

DETOUR_TRAMPOLINE(HDESK __stdcall Real_CreateDesktopA(LPCSTR a0,
                                                      LPCSTR a1,
                                                      LPDEVMODEA a2,
                                                      DWORD a3,
                                                      ACCESS_MASK a4,
                                                      LPSECURITY_ATTRIBUTES a5),
                  CreateDesktopA);

DETOUR_TRAMPOLINE(HDESK __stdcall Real_CreateDesktopW(LPCWSTR a0,
                                                      LPCWSTR a1,
                                                      LPDEVMODEW a2,
                                                      DWORD a3,
                                                      ACCESS_MASK a4,
                                                      LPSECURITY_ATTRIBUTES a5),
                  CreateDesktopW);

DETOUR_TRAMPOLINE(HWND __stdcall Real_CreateDialogIndirectParamA(HINSTANCE a0,
                                                                 LPCDLGTEMPLATEA a1,
                                                                 HWND a2,
                                                                 DLGPROC a3,
                                                                 LPARAM a4),
                  CreateDialogIndirectParamA);

DETOUR_TRAMPOLINE(HWND __stdcall Real_CreateDialogIndirectParamW(HINSTANCE a0,
                                                                 LPCDLGTEMPLATEW a1,
                                                                 HWND a2,
                                                                 DLGPROC a3,
                                                                 LPARAM a4),
                  CreateDialogIndirectParamW);

DETOUR_TRAMPOLINE(HWND __stdcall Real_CreateDialogParamA(HINSTANCE a0,
                                                         LPCSTR a1,
                                                         HWND a2,
                                                         DLGPROC a3,
                                                         LPARAM a4),
                  CreateDialogParamA);

DETOUR_TRAMPOLINE(HWND __stdcall Real_CreateDialogParamW(HINSTANCE a0,
                                                         LPCWSTR a1,
                                                         HWND a2,
                                                         DLGPROC a3,
                                                         LPARAM a4),
                  CreateDialogParamW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CreateDirectoryA(LPCSTR a0,
                                                       LPSECURITY_ATTRIBUTES a1),
                  CreateDirectoryA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CreateDirectoryExA(LPCSTR a0,
                                                         LPCSTR a1,
                                                         LPSECURITY_ATTRIBUTES a2),
                  CreateDirectoryExA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CreateDirectoryExW(LPCWSTR a0,
                                                         LPCWSTR a1,
                                                         LPSECURITY_ATTRIBUTES a2),
                  CreateDirectoryExW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CreateDirectoryW(LPCWSTR a0,
                                                       LPSECURITY_ATTRIBUTES a1),
                  CreateDirectoryW);

DETOUR_TRAMPOLINE(HBITMAP __stdcall Real_CreateDiscardableBitmap(HDC a0,
                                                                 int a1,
                                                                 int a2),
                  CreateDiscardableBitmap);

DETOUR_TRAMPOLINE(HRGN __stdcall Real_CreateEllipticRgn(int a0,
                                                        int a1,
                                                        int a2,
                                                        int a3),
                  CreateEllipticRgn);

DETOUR_TRAMPOLINE(HRGN __stdcall Real_CreateEllipticRgnIndirect(RECT* a0),
                  CreateEllipticRgnIndirect);

DETOUR_TRAMPOLINE(HDC __stdcall Real_CreateEnhMetaFileA(HDC a0,
                                                        LPCSTR a1,
                                                        RECT* a2,
                                                        LPCSTR a3),
                  CreateEnhMetaFileA);

DETOUR_TRAMPOLINE(HDC __stdcall Real_CreateEnhMetaFileW(HDC a0,
                                                        LPCWSTR a1,
                                                        RECT* a2,
                                                        LPCWSTR a3),
                  CreateEnhMetaFileW);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_CreateEventA(LPSECURITY_ATTRIBUTES a0,
                                                     BOOL a1,
                                                     BOOL a2,
                                                     LPCSTR a3),
                  CreateEventA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_CreateEventW(LPSECURITY_ATTRIBUTES a0,
                                                     BOOL a1,
                                                     BOOL a2,
                                                     LPCWSTR a3),
                  CreateEventW);

DETOUR_TRAMPOLINE(LPVOID __stdcall Real_CreateFiber(DWORD a0,
                                                    LPFIBER_START_ROUTINE a1,
                                                    LPVOID a2),
                  CreateFiber);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_CreateFileA(LPCSTR a0,
                                                    DWORD a1,
                                                    DWORD a2,
                                                    LPSECURITY_ATTRIBUTES a3,
                                                    DWORD a4,
                                                    DWORD a5,
                                                    HANDLE a6),
                  CreateFileA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_CreateFileMappingA(HANDLE a0,
                                                           LPSECURITY_ATTRIBUTES a1,
                                                           DWORD a2,
                                                           DWORD a3,
                                                           DWORD a4,
                                                           LPCSTR a5),
                  CreateFileMappingA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_CreateFileMappingW(HANDLE a0,
                                                           LPSECURITY_ATTRIBUTES a1,
                                                           DWORD a2,
                                                           DWORD a3,
                                                           DWORD a4,
                                                           LPCWSTR a5),
                  CreateFileMappingW);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CreateFileMoniker(LPCOLESTR a0,
                                                           struct IMoniker** a1),
                  CreateFileMoniker);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_CreateFileW(LPCWSTR a0,
                                                    DWORD a1,
                                                    DWORD a2,
                                                    LPSECURITY_ATTRIBUTES a3,
                                                    DWORD a4,
                                                    DWORD a5,
                                                    HANDLE a6),
                  CreateFileW);

DETOUR_TRAMPOLINE(HFONT __stdcall Real_CreateFontA(int a0,
                                                   int a1,
                                                   int a2,
                                                   int a3,
                                                   int a4,
                                                   DWORD a5,
                                                   DWORD a6,
                                                   DWORD a7,
                                                   DWORD a8,
                                                   DWORD a9,
                                                   DWORD a10,
                                                   DWORD a11,
                                                   DWORD a12,
                                                   LPCSTR a13),
                  CreateFontA);

DETOUR_TRAMPOLINE(HFONT __stdcall Real_CreateFontIndirectA(LOGFONTA* a0),
                  CreateFontIndirectA);

DETOUR_TRAMPOLINE(HFONT __stdcall Real_CreateFontIndirectW(LOGFONTW* a0),
                  CreateFontIndirectW);

DETOUR_TRAMPOLINE(HFONT __stdcall Real_CreateFontW(int a0,
                                                   int a1,
                                                   int a2,
                                                   int a3,
                                                   int a4,
                                                   DWORD a5,
                                                   DWORD a6,
                                                   DWORD a7,
                                                   DWORD a8,
                                                   DWORD a9,
                                                   DWORD a10,
                                                   DWORD a11,
                                                   DWORD a12,
                                                   LPCWSTR a13),
                  CreateFontW);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CreateGenericComposite(struct IMoniker* a0,
                                                                struct IMoniker* a1,
                                                                struct IMoniker** a2),
                  CreateGenericComposite);

DETOUR_TRAMPOLINE(HPALETTE __stdcall Real_CreateHalftonePalette(HDC a0),
                  CreateHalftonePalette);

DETOUR_TRAMPOLINE(HBRUSH __stdcall Real_CreateHatchBrush(int a0,
                                                         COLORREF a1),
                  CreateHatchBrush);

DETOUR_TRAMPOLINE(HDC __stdcall Real_CreateICA(LPCSTR a0,
                                               LPCSTR a1,
                                               LPCSTR a2,
                                               struct _devicemodeA* a3),
                  CreateICA);

DETOUR_TRAMPOLINE(HDC __stdcall Real_CreateICW(LPCWSTR a0,
                                               LPCWSTR a1,
                                               LPCWSTR a2,
                                               struct _devicemodeW* a3),
                  CreateICW);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CreateILockBytesOnHGlobal(HGLOBAL a0,
                                                                   BOOL a1,
                                                                   struct ILockBytes** a2),
                  CreateILockBytesOnHGlobal);

DETOUR_TRAMPOLINE(HICON __stdcall Real_CreateIcon(HINSTANCE a0,
                                                  int a1,
                                                  int a2,
                                                  BYTE a3,
                                                  BYTE a4,
                                                  BYTE* a5,
                                                  BYTE* a6),
                  CreateIcon);

DETOUR_TRAMPOLINE(HICON __stdcall Real_CreateIconFromResource(PBYTE a0,
                                                              DWORD a1,
                                                              BOOL a2,
                                                              DWORD a3),
                  CreateIconFromResource);

DETOUR_TRAMPOLINE(HICON __stdcall Real_CreateIconFromResourceEx(PBYTE a0,
                                                                DWORD a1,
                                                                BOOL a2,
                                                                DWORD a3,
                                                                int a4,
                                                                int a5,
                                                                UINT a6),
                  CreateIconFromResourceEx);

DETOUR_TRAMPOLINE(HICON __stdcall Real_CreateIconIndirect(struct _ICONINFO* a0),
                  CreateIconIndirect);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_CreateIoCompletionPort(HANDLE a0,
                                                               HANDLE a1,
                                                               ULONG_PTR a2,
                                                               DWORD a3),
                  CreateIoCompletionPort);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CreateItemMoniker(LPCOLESTR a0,
                                                           LPCOLESTR a1,
                                                           struct IMoniker** a2),
                  CreateItemMoniker);

DETOUR_TRAMPOLINE(HWND __stdcall Real_CreateMDIWindowA(LPCSTR a0,
                                                       LPCSTR a1,
                                                       DWORD a2,
                                                       int a3,
                                                       int a4,
                                                       int a5,
                                                       int a6,
                                                       HWND a7,
                                                       HINSTANCE a8,
                                                       LPARAM a9),
                  CreateMDIWindowA);

DETOUR_TRAMPOLINE(HWND __stdcall Real_CreateMDIWindowW(LPCWSTR a0,
                                                       LPCWSTR a1,
                                                       DWORD a2,
                                                       int a3,
                                                       int a4,
                                                       int a5,
                                                       int a6,
                                                       HWND a7,
                                                       HINSTANCE a8,
                                                       LPARAM a9),
                  CreateMDIWindowW);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_CreateMailslotA(LPCSTR a0,
                                                        DWORD a1,
                                                        DWORD a2,
                                                        LPSECURITY_ATTRIBUTES a3),
                  CreateMailslotA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_CreateMailslotW(LPCWSTR a0,
                                                        DWORD a1,
                                                        DWORD a2,
                                                        LPSECURITY_ATTRIBUTES a3),
                  CreateMailslotW);

DETOUR_TRAMPOLINE(HMENU __stdcall Real_CreateMenu(void),
                  CreateMenu);

DETOUR_TRAMPOLINE(HDC __stdcall Real_CreateMetaFileA(LPCSTR a0),
                  CreateMetaFileA);

DETOUR_TRAMPOLINE(HDC __stdcall Real_CreateMetaFileW(LPCWSTR a0),
                  CreateMetaFileW);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_CreateMutexA(LPSECURITY_ATTRIBUTES a0,
                                                     BOOL a1,
                                                     LPCSTR a2),
                  CreateMutexA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_CreateMutexW(LPSECURITY_ATTRIBUTES a0,
                                                     BOOL a1,
                                                     LPCWSTR a2),
                  CreateMutexW);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_CreateNamedPipeA(LPCSTR a0,
                                                         DWORD a1,
                                                         DWORD a2,
                                                         DWORD a3,
                                                         DWORD a4,
                                                         DWORD a5,
                                                         DWORD a6,
                                                         LPSECURITY_ATTRIBUTES a7),
                  CreateNamedPipeA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_CreateNamedPipeW(LPCWSTR a0,
                                                         DWORD a1,
                                                         DWORD a2,
                                                         DWORD a3,
                                                         DWORD a4,
                                                         DWORD a5,
                                                         DWORD a6,
                                                         LPSECURITY_ATTRIBUTES a7),
                  CreateNamedPipeW);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CreateOleAdviseHolder(LPOLEADVISEHOLDER* a0),
                  CreateOleAdviseHolder);

DETOUR_TRAMPOLINE(HPALETTE __stdcall Real_CreatePalette(LOGPALETTE* a0),
                  CreatePalette);

DETOUR_TRAMPOLINE(HBRUSH __stdcall Real_CreatePatternBrush(HBITMAP a0),
                  CreatePatternBrush);

DETOUR_TRAMPOLINE(HPEN __stdcall Real_CreatePen(int a0,
                                                int a1,
                                                COLORREF a2),
                  CreatePen);

DETOUR_TRAMPOLINE(HPEN __stdcall Real_CreatePenIndirect(LOGPEN* a0),
                  CreatePenIndirect);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CreatePipe(PHANDLE a0,
                                                 PHANDLE a1,
                                                 LPSECURITY_ATTRIBUTES a2,
                                                 DWORD a3),
                  CreatePipe);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CreatePointerMoniker(LPUNKNOWN a0,
                                                              struct IMoniker** a1),
                  CreatePointerMoniker);

DETOUR_TRAMPOLINE(HRGN __stdcall Real_CreatePolyPolygonRgn(POINT* a0,
                                                           INT* a1,
                                                           int a2,
                                                           int a3),
                  CreatePolyPolygonRgn);

DETOUR_TRAMPOLINE(HRGN __stdcall Real_CreatePolygonRgn(POINT* a0,
                                                       int a1,
                                                       int a2),
                  CreatePolygonRgn);

DETOUR_TRAMPOLINE(HMENU __stdcall Real_CreatePopupMenu(void),
                  CreatePopupMenu);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CreateProcessA(LPCSTR a0,
                                                     LPSTR a1,
                                                     LPSECURITY_ATTRIBUTES a2,
                                                     LPSECURITY_ATTRIBUTES a3,
                                                     BOOL a4,
                                                     DWORD a5,
                                                     LPVOID a6,
                                                     LPCSTR a7,
                                                     struct _STARTUPINFOA* a8,
                                                     LPPROCESS_INFORMATION a9),
                  CreateProcessA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CreateProcessW(LPCWSTR a0,
                                                     LPWSTR a1,
                                                     LPSECURITY_ATTRIBUTES a2,
                                                     LPSECURITY_ATTRIBUTES a3,
                                                     BOOL a4,
                                                     DWORD a5,
                                                     LPVOID a6,
                                                     LPCWSTR a7,
                                                     struct _STARTUPINFOW* a8,
                                                     LPPROCESS_INFORMATION a9),
                  CreateProcessW);

DETOUR_TRAMPOLINE(HRGN __stdcall Real_CreateRectRgn(int a0,
                                                    int a1,
                                                    int a2,
                                                    int a3),
                  CreateRectRgn);

DETOUR_TRAMPOLINE(HRGN __stdcall Real_CreateRectRgnIndirect(RECT* a0),
                  CreateRectRgnIndirect);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_CreateRemoteThread(HANDLE a0,
                                                           LPSECURITY_ATTRIBUTES a1,
                                                           DWORD a2,
                                                           LPTHREAD_START_ROUTINE a3,
                                                           LPVOID a4,
                                                           DWORD a5,
                                                           LPDWORD a6),
                  CreateRemoteThread);

DETOUR_TRAMPOLINE(HRGN __stdcall Real_CreateRoundRectRgn(int a0,
                                                         int a1,
                                                         int a2,
                                                         int a3,
                                                         int a4,
                                                         int a5),
                  CreateRoundRectRgn);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CreateScalableFontResourceA(DWORD a0,
                                                                  LPCSTR a1,
                                                                  LPCSTR a2,
                                                                  LPCSTR a3),
                  CreateScalableFontResourceA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_CreateScalableFontResourceW(DWORD a0,
                                                                  LPCWSTR a1,
                                                                  LPCWSTR a2,
                                                                  LPCWSTR a3),
                  CreateScalableFontResourceW);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_CreateSemaphoreA(LPSECURITY_ATTRIBUTES a0,
                                                         LONG a1,
                                                         LONG a2,
                                                         LPCSTR a3),
                  CreateSemaphoreA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_CreateSemaphoreW(LPSECURITY_ATTRIBUTES a0,
                                                         LONG a1,
                                                         LONG a2,
                                                         LPCWSTR a3),
                  CreateSemaphoreW);

DETOUR_TRAMPOLINE(HBRUSH __stdcall Real_CreateSolidBrush(COLORREF a0),
                  CreateSolidBrush);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CreateStdProgressIndicator(HWND a0,
                                                                    LPCOLESTR a1,
                                                                    IBindStatusCallback* a2,
                                                                    IBindStatusCallback** a3),
                  CreateStdProgressIndicator);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_CreateStreamOnHGlobal(HGLOBAL a0,
                                                               BOOL a1,
                                                               LPSTREAM* a2),
                  CreateStreamOnHGlobal);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_CreateTapePartition(HANDLE a0,
                                                           DWORD a1,
                                                           DWORD a2,
                                                           DWORD a3),
                  CreateTapePartition);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_CreateThread(LPSECURITY_ATTRIBUTES a0,
                                                     DWORD a1,
                                                     LPTHREAD_START_ROUTINE a2,
                                                     LPVOID a3,
                                                     DWORD a4,
                                                     LPDWORD a5),
                  CreateThread);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_CreateWaitableTimerA(LPSECURITY_ATTRIBUTES a0,
                                                             BOOL a1,
                                                             LPCSTR a2),
                  CreateWaitableTimerA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_CreateWaitableTimerW(LPSECURITY_ATTRIBUTES a0,
                                                             BOOL a1,
                                                             LPCWSTR a2),
                  CreateWaitableTimerW);

DETOUR_TRAMPOLINE(HWND __stdcall Real_CreateWindowExA(DWORD a0,
                                                      LPCSTR a1,
                                                      LPCSTR a2,
                                                      DWORD a3,
                                                      int a4,
                                                      int a5,
                                                      int a6,
                                                      int a7,
                                                      HWND a8,
                                                      HMENU a9,
                                                      HINSTANCE a10,
                                                      LPVOID a11),
                  CreateWindowExA);

DETOUR_TRAMPOLINE(HWND __stdcall Real_CreateWindowExW(DWORD a0,
                                                      LPCWSTR a1,
                                                      LPCWSTR a2,
                                                      DWORD a3,
                                                      int a4,
                                                      int a5,
                                                      int a6,
                                                      int a7,
                                                      HWND a8,
                                                      HMENU a9,
                                                      HINSTANCE a10,
                                                      LPVOID a11),
                  CreateWindowExW);

DETOUR_TRAMPOLINE(HWINSTA __stdcall Real_CreateWindowStationA(LPCSTR a0,
                                                              DWORD a1,
                                                              ACCESS_MASK a2,
                                                              LPSECURITY_ATTRIBUTES a3),
                  CreateWindowStationA);

DETOUR_TRAMPOLINE(HWINSTA __stdcall Real_CreateWindowStationW(LPCWSTR a0,
                                                              DWORD a1,
                                                              ACCESS_MASK a2,
                                                              LPSECURITY_ATTRIBUTES a3),
                  CreateWindowStationW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DPtoLP(HDC a0,
                                             struct tagPOINT* a1,
                                             int a2),
                  DPtoLP);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DdeAbandonTransaction(DWORD a0,
                                                            HCONV a1,
                                                            DWORD a2),
                  DdeAbandonTransaction);

DETOUR_TRAMPOLINE(LPBYTE __stdcall Real_DdeAccessData(HDDEDATA a0,
                                                      LPDWORD a1),
                  DdeAccessData);

DETOUR_TRAMPOLINE(HDDEDATA __stdcall Real_DdeAddData(HDDEDATA a0,
                                                     LPBYTE a1,
                                                     DWORD a2,
                                                     DWORD a3),
                  DdeAddData);

DETOUR_TRAMPOLINE(HDDEDATA __stdcall Real_DdeClientTransaction(LPBYTE a0,
                                                               DWORD a1,
                                                               HCONV a2,
                                                               HSZ a3,
                                                               UINT a4,
                                                               UINT a5,
                                                               DWORD a6,
                                                               LPDWORD a7),
                  DdeClientTransaction);

DETOUR_TRAMPOLINE(int __stdcall Real_DdeCmpStringHandles(HSZ a0,
                                                         HSZ a1),
                  DdeCmpStringHandles);

DETOUR_TRAMPOLINE(HCONV __stdcall Real_DdeConnect(DWORD a0,
                                                  HSZ a1,
                                                  HSZ a2,
                                                  PCONVCONTEXT a3),
                  DdeConnect);

DETOUR_TRAMPOLINE(HCONVLIST __stdcall Real_DdeConnectList(DWORD a0,
                                                          HSZ a1,
                                                          HSZ a2,
                                                          HCONVLIST a3,
                                                          PCONVCONTEXT a4),
                  DdeConnectList);

DETOUR_TRAMPOLINE(HDDEDATA __stdcall Real_DdeCreateDataHandle(DWORD a0,
                                                              LPBYTE a1,
                                                              DWORD a2,
                                                              DWORD a3,
                                                              HSZ a4,
                                                              UINT a5,
                                                              UINT a6),
                  DdeCreateDataHandle);

DETOUR_TRAMPOLINE(HSZ __stdcall Real_DdeCreateStringHandleA(DWORD a0,
                                                            LPCSTR a1,
                                                            int a2),
                  DdeCreateStringHandleA);

DETOUR_TRAMPOLINE(HSZ __stdcall Real_DdeCreateStringHandleW(DWORD a0,
                                                            LPCWSTR a1,
                                                            int a2),
                  DdeCreateStringHandleW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DdeDisconnect(HCONV a0),
                  DdeDisconnect);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DdeDisconnectList(HCONVLIST a0),
                  DdeDisconnectList);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DdeEnableCallback(DWORD a0,
                                                        HCONV a1,
                                                        UINT a2),
                  DdeEnableCallback);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DdeFreeDataHandle(HDDEDATA a0),
                  DdeFreeDataHandle);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DdeFreeStringHandle(DWORD a0,
                                                          HSZ a1),
                  DdeFreeStringHandle);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_DdeGetData(HDDEDATA a0,
                                                  LPBYTE a1,
                                                  DWORD a2,
                                                  DWORD a3),
                  DdeGetData);

DETOUR_TRAMPOLINE(UINT __stdcall Real_DdeGetLastError(DWORD a0),
                  DdeGetLastError);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DdeImpersonateClient(HCONV a0),
                  DdeImpersonateClient);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DdeKeepStringHandle(DWORD a0,
                                                          HSZ a1),
                  DdeKeepStringHandle);

DETOUR_TRAMPOLINE(HDDEDATA __stdcall Real_DdeNameService(DWORD a0,
                                                         HSZ a1,
                                                         HSZ a2,
                                                         UINT a3),
                  DdeNameService);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DdePostAdvise(DWORD a0,
                                                    HSZ a1,
                                                    HSZ a2),
                  DdePostAdvise);

DETOUR_TRAMPOLINE(UINT __stdcall Real_DdeQueryConvInfo(HCONV a0,
                                                       DWORD a1,
                                                       struct tagCONVINFO* a2),
                  DdeQueryConvInfo);

DETOUR_TRAMPOLINE(HCONV __stdcall Real_DdeQueryNextServer(HCONVLIST a0,
                                                          HCONV a1),
                  DdeQueryNextServer);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_DdeQueryStringA(DWORD a0,
                                                       HSZ a1,
                                                       LPSTR a2,
                                                       DWORD a3,
                                                       int a4),
                  DdeQueryStringA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_DdeQueryStringW(DWORD a0,
                                                       HSZ a1,
                                                       LPWSTR a2,
                                                       DWORD a3,
                                                       int a4),
                  DdeQueryStringW);

DETOUR_TRAMPOLINE(HCONV __stdcall Real_DdeReconnect(HCONV a0),
                  DdeReconnect);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DdeSetQualityOfService(HWND a0,
                                                             SECURITY_QUALITY_OF_SERVICE* a1,
                                                             struct _SECURITY_QUALITY_OF_SERVICE* a2),
                  DdeSetQualityOfService);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DdeSetUserHandle(HCONV a0,
                                                       DWORD a1,
                                                       DWORD a2),
                  DdeSetUserHandle);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DdeUnaccessData(HDDEDATA a0),
                  DdeUnaccessData);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DdeUninitialize(DWORD a0),
                  DdeUninitialize);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DebugActiveProcess(DWORD a0),
                  DebugActiveProcess);

DETOUR_TRAMPOLINE(void __stdcall Real_DebugBreak(void),
                  DebugBreak);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_DefDlgProcA(HWND a0,
                                                     UINT a1,
                                                     WPARAM a2,
                                                     LPARAM a3),
                  DefDlgProcA);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_DefDlgProcW(HWND a0,
                                                     UINT a1,
                                                     WPARAM a2,
                                                     LPARAM a3),
                  DefDlgProcW);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_DefFrameProcA(HWND a0,
                                                       HWND a1,
                                                       UINT a2,
                                                       WPARAM a3,
                                                       LPARAM a4),
                  DefFrameProcA);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_DefFrameProcW(HWND a0,
                                                       HWND a1,
                                                       UINT a2,
                                                       WPARAM a3,
                                                       LPARAM a4),
                  DefFrameProcW);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_DefMDIChildProcA(HWND a0,
                                                          UINT a1,
                                                          WPARAM a2,
                                                          LPARAM a3),
                  DefMDIChildProcA);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_DefMDIChildProcW(HWND a0,
                                                          UINT a1,
                                                          WPARAM a2,
                                                          LPARAM a3),
                  DefMDIChildProcW);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_DefWindowProcA(HWND a0,
                                                        UINT a1,
                                                        WPARAM a2,
                                                        LPARAM a3),
                  DefWindowProcA);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_DefWindowProcW(HWND a0,
                                                        UINT a1,
                                                        WPARAM a2,
                                                        LPARAM a3),
                  DefWindowProcW);

DETOUR_TRAMPOLINE(HDWP __stdcall Real_DeferWindowPos(HDWP a0,
                                                     HWND a1,
                                                     HWND a2,
                                                     int a3,
                                                     int a4,
                                                     int a5,
                                                     int a6,
                                                     UINT a7),
                  DeferWindowPos);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DefineDosDeviceA(DWORD a0,
                                                       LPCSTR a1,
                                                       LPCSTR a2),
                  DefineDosDeviceA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DefineDosDeviceW(DWORD a0,
                                                       LPCWSTR a1,
                                                       LPCWSTR a2),
                  DefineDosDeviceW);

DETOUR_TRAMPOLINE(ATOM __stdcall Real_DeleteAtom(ATOM a0),
                  DeleteAtom);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DeleteColorSpace(HCOLORSPACE a0),
                  DeleteColorSpace);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DeleteDC(HDC a0),
                  DeleteDC);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DeleteEnhMetaFile(HENHMETAFILE a0),
                  DeleteEnhMetaFile);

DETOUR_TRAMPOLINE(void __stdcall Real_DeleteFiber(LPVOID a0),
                  DeleteFiber);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DeleteFileA(LPCSTR a0),
                  DeleteFileA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DeleteFileW(LPCWSTR a0),
                  DeleteFileW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DeleteMenu(HMENU a0,
                                                 UINT a1,
                                                 UINT a2),
                  DeleteMenu);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DeleteMetaFile(HMETAFILE a0),
                  DeleteMetaFile);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DeleteObject(HGDIOBJ a0),
                  DeleteObject);

DETOUR_TRAMPOLINE(int __stdcall Real_DescribePixelFormat(HDC a0,
                                                         int a1,
                                                         UINT a2,
                                                         struct tagPIXELFORMATDESCRIPTOR* a3),
                  DescribePixelFormat);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DestroyAcceleratorTable(HACCEL a0),
                  DestroyAcceleratorTable);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DestroyCaret(void),
                  DestroyCaret);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DestroyCursor(HCURSOR a0),
                  DestroyCursor);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DestroyIcon(HICON a0),
                  DestroyIcon);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DestroyMenu(HMENU a0),
                  DestroyMenu);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DestroyWindow(HWND a0),
                  DestroyWindow);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DeviceIoControl(HANDLE a0,
                                                      DWORD a1,
                                                      LPVOID a2,
                                                      DWORD a3,
                                                      LPVOID a4,
                                                      DWORD a5,
                                                      LPDWORD a6,
                                                      LPOVERLAPPED a7),
                  DeviceIoControl);

DETOUR_TRAMPOLINE(INT_PTR __stdcall Real_DialogBoxIndirectParamA(HINSTANCE a0,
                                                                 LPCDLGTEMPLATEA a1,
                                                                 HWND a2,
                                                                 DLGPROC a3,
                                                                 LPARAM a4),
                  DialogBoxIndirectParamA);

DETOUR_TRAMPOLINE(INT_PTR __stdcall Real_DialogBoxIndirectParamW(HINSTANCE a0,
                                                                 LPCDLGTEMPLATEW a1,
                                                                 HWND a2,
                                                                 DLGPROC a3,
                                                                 LPARAM a4),
                  DialogBoxIndirectParamW);

DETOUR_TRAMPOLINE(INT_PTR __stdcall Real_DialogBoxParamA(HINSTANCE a0,
                                                         LPCSTR a1,
                                                         HWND a2,
                                                         DLGPROC a3,
                                                         LPARAM a4),
                  DialogBoxParamA);

DETOUR_TRAMPOLINE(INT_PTR __stdcall Real_DialogBoxParamW(HINSTANCE a0,
                                                         LPCWSTR a1,
                                                         HWND a2,
                                                         DLGPROC a3,
                                                         LPARAM a4),
                  DialogBoxParamW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DisableThreadLibraryCalls(HMODULE a0),
                  DisableThreadLibraryCalls);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DisconnectNamedPipe(HANDLE a0),
                  DisconnectNamedPipe);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_DispatchMessageA(struct tagMSG* a0),
                  DispatchMessageA);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_DispatchMessageW(struct tagMSG* a0),
                  DispatchMessageW);

DETOUR_TRAMPOLINE(int __stdcall Real_DlgDirListA(HWND a0,
                                                 LPSTR a1,
                                                 int a2,
                                                 int a3,
                                                 UINT a4),
                  DlgDirListA);

DETOUR_TRAMPOLINE(int __stdcall Real_DlgDirListComboBoxA(HWND a0,
                                                         LPSTR a1,
                                                         int a2,
                                                         int a3,
                                                         UINT a4),
                  DlgDirListComboBoxA);

DETOUR_TRAMPOLINE(int __stdcall Real_DlgDirListComboBoxW(HWND a0,
                                                         LPWSTR a1,
                                                         int a2,
                                                         int a3,
                                                         UINT a4),
                  DlgDirListComboBoxW);

DETOUR_TRAMPOLINE(int __stdcall Real_DlgDirListW(HWND a0,
                                                 LPWSTR a1,
                                                 int a2,
                                                 int a3,
                                                 UINT a4),
                  DlgDirListW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DlgDirSelectComboBoxExA(HWND a0,
                                                              LPSTR a1,
                                                              int a2,
                                                              int a3),
                  DlgDirSelectComboBoxExA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DlgDirSelectComboBoxExW(HWND a0,
                                                              LPWSTR a1,
                                                              int a2,
                                                              int a3),
                  DlgDirSelectComboBoxExW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DlgDirSelectExA(HWND a0,
                                                      LPSTR a1,
                                                      int a2,
                                                      int a3),
                  DlgDirSelectExA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DlgDirSelectExW(HWND a0,
                                                      LPWSTR a1,
                                                      int a2,
                                                      int a3),
                  DlgDirSelectExW);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_DoDragDrop(struct IDataObject* a0,
                                                    struct IDropSource* a1,
                                                    DWORD a2,
                                                    LPDWORD a3),
                  DoDragDrop);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DosDateTimeToFileTime(WORD a0,
                                                            WORD a1,
                                                            LPFILETIME a2),
                  DosDateTimeToFileTime);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DragDetect(HWND a0,
                                                 POINT a1),
                  DragDetect);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_DragObject(HWND a0,
                                                  HWND a1,
                                                  UINT a2,
                                                  ULONG_PTR a3,
                                                  HCURSOR a4),
                  DragObject);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DrawAnimatedRects(HWND a0,
                                                        int a1,
                                                        RECT* a2,
                                                        RECT* a3),
                  DrawAnimatedRects);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DrawCaption(HWND a0,
                                                  HDC a1,
                                                  RECT* a2,
                                                  UINT a3),
                  DrawCaption);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DrawEdge(HDC a0,
                                               LPRECT a1,
                                               UINT a2,
                                               UINT a3),
                  DrawEdge);

DETOUR_TRAMPOLINE(int __stdcall Real_DrawEscape(HDC a0,
                                                int a1,
                                                int a2,
                                                LPCSTR a3),
                  DrawEscape);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DrawFocusRect(HDC a0,
                                                    RECT* a1),
                  DrawFocusRect);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DrawFrameControl(HDC a0,
                                                       LPRECT a1,
                                                       UINT a2,
                                                       UINT a3),
                  DrawFrameControl);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DrawIcon(HDC a0,
                                               int a1,
                                               int a2,
                                               HICON a3),
                  DrawIcon);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DrawIconEx(HDC a0,
                                                 int a1,
                                                 int a2,
                                                 HICON a3,
                                                 int a4,
                                                 int a5,
                                                 UINT a6,
                                                 HBRUSH a7,
                                                 UINT a8),
                  DrawIconEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DrawMenuBar(HWND a0),
                  DrawMenuBar);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DrawStateA(HDC a0,
                                                 HBRUSH a1,
                                                 DRAWSTATEPROC a2,
                                                 LPARAM a3,
                                                 WPARAM a4,
                                                 int a5,
                                                 int a6,
                                                 int a7,
                                                 int a8,
                                                 UINT a9),
                  DrawStateA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DrawStateW(HDC a0,
                                                 HBRUSH a1,
                                                 DRAWSTATEPROC a2,
                                                 LPARAM a3,
                                                 WPARAM a4,
                                                 int a5,
                                                 int a6,
                                                 int a7,
                                                 int a8,
                                                 UINT a9),
                  DrawStateW);

DETOUR_TRAMPOLINE(int __stdcall Real_DrawTextA(HDC a0,
                                               LPCSTR a1,
                                               int a2,
                                               LPRECT a3,
                                               UINT a4),
                  DrawTextA);

DETOUR_TRAMPOLINE(int __stdcall Real_DrawTextExA(HDC a0,
                                                 LPSTR a1,
                                                 int a2,
                                                 LPRECT a3,
                                                 UINT a4,
                                                 LPDRAWTEXTPARAMS a5),
                  DrawTextExA);

DETOUR_TRAMPOLINE(int __stdcall Real_DrawTextExW(HDC a0,
                                                 LPWSTR a1,
                                                 int a2,
                                                 LPRECT a3,
                                                 UINT a4,
                                                 LPDRAWTEXTPARAMS a5),
                  DrawTextExW);

DETOUR_TRAMPOLINE(int __stdcall Real_DrawTextW(HDC a0,
                                               LPCWSTR a1,
                                               int a2,
                                               LPRECT a3,
                                               UINT a4),
                  DrawTextW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_DuplicateHandle(HANDLE a0,
                                                      HANDLE a1,
                                                      HANDLE a2,
                                                      LPHANDLE a3,
                                                      DWORD a4,
                                                      BOOL a5,
                                                      DWORD a6),
                  DuplicateHandle);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_Ellipse(HDC a0,
                                              int a1,
                                              int a2,
                                              int a3,
                                              int a4),
                  Ellipse);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EmptyClipboard(void),
                  EmptyClipboard);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnableMenuItem(HMENU a0,
                                                     UINT a1,
                                                     UINT a2),
                  EnableMenuItem);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnableScrollBar(HWND a0,
                                                      UINT a1,
                                                      UINT a2),
                  EnableScrollBar);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnableWindow(HWND a0,
                                                   BOOL a1),
                  EnableWindow);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EndDeferWindowPos(HDWP a0),
                  EndDeferWindowPos);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EndDialog(HWND a0,
                                                INT_PTR a1),
                  EndDialog);

DETOUR_TRAMPOLINE(int __stdcall Real_EndDoc(HDC a0),
                  EndDoc);

DETOUR_TRAMPOLINE(int __stdcall Real_EndPage(HDC a0),
                  EndPage);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EndPaint(HWND a0,
                                               PAINTSTRUCT* a1),
                  EndPaint);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EndPath(HDC a0),
                  EndPath);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EndUpdateResourceA(HANDLE a0,
                                                         BOOL a1),
                  EndUpdateResourceA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EndUpdateResourceW(HANDLE a0,
                                                         BOOL a1),
                  EndUpdateResourceW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumCalendarInfoA(CALINFO_ENUMPROCA a0,
                                                        LCID a1,
                                                        CALID a2,
                                                        CALTYPE a3),
                  EnumCalendarInfoA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumCalendarInfoW(CALINFO_ENUMPROCW a0,
                                                        LCID a1,
                                                        CALID a2,
                                                        CALTYPE a3),
                  EnumCalendarInfoW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumChildWindows(HWND a0,
                                                       WNDENUMPROC a1,
                                                       LPARAM a2),
                  EnumChildWindows);

DETOUR_TRAMPOLINE(UINT __stdcall Real_EnumClipboardFormats(UINT a0),
                  EnumClipboardFormats);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumDateFormatsA(DATEFMT_ENUMPROCA a0,
                                                       LCID a1,
                                                       DWORD a2),
                  EnumDateFormatsA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumDateFormatsW(DATEFMT_ENUMPROCW a0,
                                                       LCID a1,
                                                       DWORD a2),
                  EnumDateFormatsW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumDesktopWindows(HDESK a0,
                                                         WNDENUMPROC a1,
                                                         LPARAM a2),
                  EnumDesktopWindows);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumDesktopsA(HWINSTA a0,
                                                    DESKTOPENUMPROCA a1,
                                                    LPARAM a2),
                  EnumDesktopsA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumDesktopsW(HWINSTA a0,
                                                    DESKTOPENUMPROCW a1,
                                                    LPARAM a2),
                  EnumDesktopsW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumDisplaySettingsA(LPCSTR a0,
                                                           DWORD a1,
                                                           LPDEVMODEA a2),
                  EnumDisplaySettingsA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumDisplaySettingsW(LPCWSTR a0,
                                                           DWORD a1,
                                                           LPDEVMODEW a2),
                  EnumDisplaySettingsW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumEnhMetaFile(HDC a0,
                                                      HENHMETAFILE a1,
                                                      ENHMFENUMPROC a2,
                                                      LPVOID a3,
                                                      RECT* a4),
                  EnumEnhMetaFile);

DETOUR_TRAMPOLINE(int __stdcall Real_EnumFontFamiliesA(HDC a0,
                                                       LPCSTR a1,
                                                       FONTENUMPROCA a2,
                                                       LPARAM a3),
                  EnumFontFamiliesA);

DETOUR_TRAMPOLINE(int __stdcall Real_EnumFontFamiliesExA(HDC a0,
                                                         LPLOGFONTA a1,
                                                         FONTENUMPROCA a2,
                                                         LPARAM a3,
                                                         DWORD a4),
                  EnumFontFamiliesExA);

DETOUR_TRAMPOLINE(int __stdcall Real_EnumFontFamiliesExW(HDC a0,
                                                         LPLOGFONTW a1,
                                                         FONTENUMPROCW a2,
                                                         LPARAM a3,
                                                         DWORD a4),
                  EnumFontFamiliesExW);

DETOUR_TRAMPOLINE(int __stdcall Real_EnumFontFamiliesW(HDC a0,
                                                       LPCWSTR a1,
                                                       FONTENUMPROCW a2,
                                                       LPARAM a3),
                  EnumFontFamiliesW);

DETOUR_TRAMPOLINE(int __stdcall Real_EnumFontsA(HDC a0,
                                                LPCSTR a1,
                                                FONTENUMPROCA a2,
                                                LPARAM a3),
                  EnumFontsA);

DETOUR_TRAMPOLINE(int __stdcall Real_EnumFontsW(HDC a0,
                                                LPCWSTR a1,
                                                FONTENUMPROCW a2,
                                                LPARAM a3),
                  EnumFontsW);

DETOUR_TRAMPOLINE(int __stdcall Real_EnumICMProfilesA(HDC a0,
                                                      ICMENUMPROCA a1,
                                                      LPARAM a2),
                  EnumICMProfilesA);

DETOUR_TRAMPOLINE(int __stdcall Real_EnumICMProfilesW(HDC a0,
                                                      ICMENUMPROCW a1,
                                                      LPARAM a2),
                  EnumICMProfilesW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumMetaFile(HDC a0,
                                                   HMETAFILE a1,
                                                   MFENUMPROC a2,
                                                   LPARAM a3),
                  EnumMetaFile);

DETOUR_TRAMPOLINE(int __stdcall Real_EnumObjects(HDC a0,
                                                 int a1,
                                                 GOBJENUMPROC a2,
                                                 LPARAM a3),
                  EnumObjects);

DETOUR_TRAMPOLINE(int __stdcall Real_EnumPropsA(HWND a0,
                                                PROPENUMPROCA a1),
                  EnumPropsA);

DETOUR_TRAMPOLINE(int __stdcall Real_EnumPropsExA(HWND a0,
                                                  PROPENUMPROCEXA a1,
                                                  LPARAM a2),
                  EnumPropsExA);

DETOUR_TRAMPOLINE(int __stdcall Real_EnumPropsExW(HWND a0,
                                                  PROPENUMPROCEXW a1,
                                                  LPARAM a2),
                  EnumPropsExW);

DETOUR_TRAMPOLINE(int __stdcall Real_EnumPropsW(HWND a0,
                                                PROPENUMPROCW a1),
                  EnumPropsW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumResourceLanguagesA(HMODULE a0,
                                                             LPCSTR a1,
                                                             LPCSTR a2,
                                                             ENUMRESLANGPROCA a3,
                                                             LONG_PTR a4),
                  EnumResourceLanguagesA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumResourceLanguagesW(HMODULE a0,
                                                             LPCWSTR a1,
                                                             LPCWSTR a2,
                                                             ENUMRESLANGPROCW a3,
                                                             LONG_PTR a4),
                  EnumResourceLanguagesW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumResourceNamesA(HMODULE a0,
                                                         LPCSTR a1,
                                                         ENUMRESNAMEPROCA a2,
                                                         LONG_PTR a3),
                  EnumResourceNamesA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumResourceNamesW(HMODULE a0,
                                                         LPCWSTR a1,
                                                         ENUMRESNAMEPROCW a2,
                                                         LONG_PTR a3),
                  EnumResourceNamesW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumResourceTypesA(HMODULE a0,
                                                         ENUMRESTYPEPROCA a1,
                                                         LONG_PTR a2),
                  EnumResourceTypesA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumResourceTypesW(HMODULE a0,
                                                         ENUMRESTYPEPROCW a1,
                                                         LONG_PTR a2),
                  EnumResourceTypesW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumSystemCodePagesA(CODEPAGE_ENUMPROCA a0,
                                                           DWORD a1),
                  EnumSystemCodePagesA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumSystemCodePagesW(CODEPAGE_ENUMPROCW a0,
                                                           DWORD a1),
                  EnumSystemCodePagesW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumSystemLocalesA(LOCALE_ENUMPROCA a0,
                                                         DWORD a1),
                  EnumSystemLocalesA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumSystemLocalesW(LOCALE_ENUMPROCW a0,
                                                         DWORD a1),
                  EnumSystemLocalesW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumThreadWindows(DWORD a0,
                                                        WNDENUMPROC a1,
                                                        LPARAM a2),
                  EnumThreadWindows);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumTimeFormatsA(TIMEFMT_ENUMPROCA a0,
                                                       LCID a1,
                                                       DWORD a2),
                  EnumTimeFormatsA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumTimeFormatsW(TIMEFMT_ENUMPROCW a0,
                                                       LCID a1,
                                                       DWORD a2),
                  EnumTimeFormatsW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumWindowStationsA(WINSTAENUMPROCA a0,
                                                          LPARAM a1),
                  EnumWindowStationsA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumWindowStationsW(WINSTAENUMPROCW a0,
                                                          LPARAM a1),
                  EnumWindowStationsW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EnumWindows(WNDENUMPROC a0,
                                                  LPARAM a1),
                  EnumWindows);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EqualRect(RECT* a0,
                                                RECT* a1),
                  EqualRect);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EqualRgn(HRGN a0,
                                               HRGN a1),
                  EqualRgn);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_EraseTape(HANDLE a0,
                                                 DWORD a1,
                                                 BOOL a2),
                  EraseTape);

DETOUR_TRAMPOLINE(int __stdcall Real_Escape(HDC a0,
                                            int a1,
                                            int a2,
                                            LPCSTR a3,
                                            LPVOID a4),
                  Escape);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_EscapeCommFunction(HANDLE a0,
                                                         DWORD a1),
                  EscapeCommFunction);

DETOUR_TRAMPOLINE(int __stdcall Real_ExcludeClipRect(HDC a0,
                                                     int a1,
                                                     int a2,
                                                     int a3,
                                                     int a4),
                  ExcludeClipRect);

DETOUR_TRAMPOLINE(int __stdcall Real_ExcludeUpdateRgn(HDC a0,
                                                      HWND a1),
                  ExcludeUpdateRgn);

DETOUR_TRAMPOLINE(void __stdcall Real_ExitProcess(UINT a0),
                  ExitProcess);

DETOUR_TRAMPOLINE(void __stdcall Real_ExitThread(DWORD a0),
                  ExitThread);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ExitWindowsEx(UINT a0,
                                                    DWORD a1),
                  ExitWindowsEx);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_ExpandEnvironmentStringsA(LPCSTR a0,
                                                                 LPSTR a1,
                                                                 DWORD a2),
                  ExpandEnvironmentStringsA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_ExpandEnvironmentStringsW(LPCWSTR a0,
                                                                 LPWSTR a1,
                                                                 DWORD a2),
                  ExpandEnvironmentStringsW);

DETOUR_TRAMPOLINE(HPEN __stdcall Real_ExtCreatePen(DWORD a0,
                                                   DWORD a1,
                                                   struct tagLOGBRUSH* a2,
                                                   DWORD a3,
                                                   DWORD* a4),
                  ExtCreatePen);

DETOUR_TRAMPOLINE(HRGN __stdcall Real_ExtCreateRegion(XFORM* a0,
                                                      DWORD a1,
                                                      RGNDATA* a2),
                  ExtCreateRegion);

DETOUR_TRAMPOLINE(int __stdcall Real_ExtEscape(HDC a0,
                                               int a1,
                                               int a2,
                                               LPCSTR a3,
                                               int a4,
                                               LPSTR a5),
                  ExtEscape);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ExtFloodFill(HDC a0,
                                                   int a1,
                                                   int a2,
                                                   COLORREF a3,
                                                   UINT a4),
                  ExtFloodFill);

DETOUR_TRAMPOLINE(int __stdcall Real_ExtSelectClipRgn(HDC a0,
                                                      HRGN a1,
                                                      int a2),
                  ExtSelectClipRgn);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ExtTextOutA(HDC a0,
                                                  int a1,
                                                  int a2,
                                                  UINT a3,
                                                  RECT* a4,
                                                  LPCSTR a5,
                                                  UINT a6,
                                                  INT* a7),
                  ExtTextOutA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ExtTextOutW(HDC a0,
                                                  int a1,
                                                  int a2,
                                                  UINT a3,
                                                  RECT* a4,
                                                  LPCWSTR a5,
                                                  UINT a6,
                                                  INT* a7),
                  ExtTextOutW);

DETOUR_TRAMPOLINE(void __stdcall Real_FatalAppExitA(UINT a0,
                                                    LPCSTR a1),
                  FatalAppExitA);

DETOUR_TRAMPOLINE(void __stdcall Real_FatalAppExitW(UINT a0,
                                                    LPCWSTR a1),
                  FatalAppExitW);

DETOUR_TRAMPOLINE(void __stdcall Real_FatalExit(int a0),
                  FatalExit);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FileTimeToDosDateTime(FILETIME* a0,
                                                            LPWORD a1,
                                                            LPWORD a2),
                  FileTimeToDosDateTime);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FileTimeToLocalFileTime(FILETIME* a0,
                                                              LPFILETIME a1),
                  FileTimeToLocalFileTime);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FileTimeToSystemTime(FILETIME* a0,
                                                           struct _SYSTEMTIME* a1),
                  FileTimeToSystemTime);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FillConsoleOutputAttribute(HANDLE a0,
                                                                 WORD a1,
                                                                 DWORD a2,
                                                                 COORD a3,
                                                                 LPDWORD a4),
                  FillConsoleOutputAttribute);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FillConsoleOutputCharacterA(HANDLE a0,
                                                                  CHAR a1,
                                                                  DWORD a2,
                                                                  COORD a3,
                                                                  LPDWORD a4),
                  FillConsoleOutputCharacterA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FillConsoleOutputCharacterW(HANDLE a0,
                                                                  WCHAR a1,
                                                                  DWORD a2,
                                                                  COORD a3,
                                                                  LPDWORD a4),
                  FillConsoleOutputCharacterW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FillPath(HDC a0),
                  FillPath);

DETOUR_TRAMPOLINE(int __stdcall Real_FillRect(HDC a0,
                                              RECT* a1,
                                              HBRUSH a2),
                  FillRect);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FillRgn(HDC a0,
                                              HRGN a1,
                                              HBRUSH a2),
                  FillRgn);

DETOUR_TRAMPOLINE(ATOM __stdcall Real_FindAtomA(LPCSTR a0),
                  FindAtomA);

DETOUR_TRAMPOLINE(ATOM __stdcall Real_FindAtomW(LPCWSTR a0),
                  FindAtomW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FindClose(HANDLE a0),
                  FindClose);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FindCloseChangeNotification(HANDLE a0),
                  FindCloseChangeNotification);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_FindFirstChangeNotificationA(LPCSTR a0,
                                                                     BOOL a1,
                                                                     DWORD a2),
                  FindFirstChangeNotificationA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_FindFirstChangeNotificationW(LPCWSTR a0,
                                                                     BOOL a1,
                                                                     DWORD a2),
                  FindFirstChangeNotificationW);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_FindFirstFileA(LPCSTR a0,
                                                       LPWIN32_FIND_DATAA a1),
                  FindFirstFileA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_FindFirstFileExA(LPCSTR a0,
                                                         FINDEX_INFO_LEVELS a1,
                                                         LPVOID a2,
                                                         FINDEX_SEARCH_OPS a3,
                                                         LPVOID a4,
                                                         DWORD a5),
                  FindFirstFileExA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_FindFirstFileExW(LPCWSTR a0,
                                                         FINDEX_INFO_LEVELS a1,
                                                         LPVOID a2,
                                                         FINDEX_SEARCH_OPS a3,
                                                         LPVOID a4,
                                                         DWORD a5),
                  FindFirstFileExW);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_FindFirstFileW(LPCWSTR a0,
                                                       LPWIN32_FIND_DATAW a1),
                  FindFirstFileW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FindNextChangeNotification(HANDLE a0),
                  FindNextChangeNotification);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FindNextFileA(HANDLE a0,
                                                    LPWIN32_FIND_DATAA a1),
                  FindNextFileA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FindNextFileW(HANDLE a0,
                                                    LPWIN32_FIND_DATAW a1),
                  FindNextFileW);

DETOUR_TRAMPOLINE(HRSRC __stdcall Real_FindResourceA(HMODULE a0,
                                                     LPCSTR a1,
                                                     LPCSTR a2),
                  FindResourceA);

DETOUR_TRAMPOLINE(HRSRC __stdcall Real_FindResourceExA(HMODULE a0,
                                                       LPCSTR a1,
                                                       LPCSTR a2,
                                                       WORD a3),
                  FindResourceExA);

DETOUR_TRAMPOLINE(HRSRC __stdcall Real_FindResourceExW(HMODULE a0,
                                                       LPCWSTR a1,
                                                       LPCWSTR a2,
                                                       WORD a3),
                  FindResourceExW);

DETOUR_TRAMPOLINE(HRSRC __stdcall Real_FindResourceW(HMODULE a0,
                                                     LPCWSTR a1,
                                                     LPCWSTR a2),
                  FindResourceW);

DETOUR_TRAMPOLINE(HWND __stdcall Real_FindWindowA(LPCSTR a0,
                                                  LPCSTR a1),
                  FindWindowA);

DETOUR_TRAMPOLINE(HWND __stdcall Real_FindWindowExA(HWND a0,
                                                    HWND a1,
                                                    LPCSTR a2,
                                                    LPCSTR a3),
                  FindWindowExA);

DETOUR_TRAMPOLINE(HWND __stdcall Real_FindWindowExW(HWND a0,
                                                    HWND a1,
                                                    LPCWSTR a2,
                                                    LPCWSTR a3),
                  FindWindowExW);

DETOUR_TRAMPOLINE(HWND __stdcall Real_FindWindowW(LPCWSTR a0,
                                                  LPCWSTR a1),
                  FindWindowW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FixBrushOrgEx(HDC a0,
                                                    int a1,
                                                    int a2,
                                                    struct tagPOINT* a3),
                  FixBrushOrgEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FlashWindow(HWND a0,
                                                  BOOL a1),
                  FlashWindow);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FlattenPath(HDC a0),
                  FlattenPath);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FloodFill(HDC a0,
                                                int a1,
                                                int a2,
                                                COLORREF a3),
                  FloodFill);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FlushConsoleInputBuffer(HANDLE a0),
                  FlushConsoleInputBuffer);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FlushFileBuffers(HANDLE a0),
                  FlushFileBuffers);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FlushViewOfFile(LPCVOID a0,
                                                      SIZE_T a1),
                  FlushViewOfFile);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_FmtIdToPropStgName(FMTID* a0,
                                                            LPOLESTR a1),
                  FmtIdToPropStgName);

DETOUR_TRAMPOLINE(int __stdcall Real_FoldStringA(DWORD a0,
                                                 LPCSTR a1,
                                                 int a2,
                                                 LPSTR a3,
                                                 int a4),
                  FoldStringA);

DETOUR_TRAMPOLINE(int __stdcall Real_FoldStringW(DWORD a0,
                                                 LPCWSTR a1,
                                                 int a2,
                                                 LPWSTR a3,
                                                 int a4),
                  FoldStringW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_FormatMessageA(DWORD a0,
                                                      LPCVOID a1,
                                                      DWORD a2,
                                                      DWORD a3,
                                                      LPSTR a4,
                                                      DWORD a5,
                                                      va_list* a6),
                  FormatMessageA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_FormatMessageW(DWORD a0,
                                                      LPCVOID a1,
                                                      DWORD a2,
                                                      DWORD a3,
                                                      LPWSTR a4,
                                                      DWORD a5,
                                                      va_list* a6),
                  FormatMessageW);

DETOUR_TRAMPOLINE(int __stdcall Real_FrameRect(HDC a0,
                                               RECT* a1,
                                               HBRUSH a2),
                  FrameRect);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FrameRgn(HDC a0,
                                               HRGN a1,
                                               HBRUSH a2,
                                               int a3,
                                               int a4),
                  FrameRgn);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FreeConsole(void),
                  FreeConsole);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FreeDDElParam(UINT a0,
                                                    LPARAM a1),
                  FreeDDElParam);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FreeEnvironmentStringsA(LPSTR a0),
                  FreeEnvironmentStringsA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FreeEnvironmentStringsW(LPWSTR a0),
                  FreeEnvironmentStringsW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FreeLibrary(HMODULE a0),
                  FreeLibrary);

DETOUR_TRAMPOLINE(void __stdcall Real_FreeLibraryAndExitThread(HMODULE a0,
                                                               DWORD a1),
                  FreeLibraryAndExitThread);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_FreePropVariantArray(ULONG a0,
                                                              PROPVARIANT* a1),
                  FreePropVariantArray);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_FreeResource(HGLOBAL a0),
                  FreeResource);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GdiComment(HDC a0,
                                                 UINT a1,
                                                 BYTE* a2),
                  GdiComment);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GdiFlush(void),
                  GdiFlush);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GdiGetBatchLimit(void),
                  GdiGetBatchLimit);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GdiSetBatchLimit(DWORD a0),
                  GdiSetBatchLimit);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GenerateConsoleCtrlEvent(DWORD a0,
                                                               DWORD a1),
                  GenerateConsoleCtrlEvent);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetACP(void),
                  GetACP);

DETOUR_TRAMPOLINE(HWND __stdcall Real_GetActiveWindow(void),
                  GetActiveWindow);

DETOUR_TRAMPOLINE(int __stdcall Real_GetArcDirection(HDC a0),
                  GetArcDirection);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetAspectRatioFilterEx(HDC a0,
                                                             struct tagSIZE* a1),
                  GetAspectRatioFilterEx);

DETOUR_TRAMPOLINE(SHORT __stdcall Real_GetAsyncKeyState(int a0),
                  GetAsyncKeyState);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetAtomNameA(ATOM a0,
                                                   LPSTR a1,
                                                   int a2),
                  GetAtomNameA);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetAtomNameW(ATOM a0,
                                                   LPWSTR a1,
                                                   int a2),
                  GetAtomNameW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetBinaryTypeA(LPCSTR a0,
                                                     LPDWORD a1),
                  GetBinaryTypeA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetBinaryTypeW(LPCWSTR a0,
                                                     LPDWORD a1),
                  GetBinaryTypeW);

DETOUR_TRAMPOLINE(LONG __stdcall Real_GetBitmapBits(HBITMAP a0,
                                                    LONG a1,
                                                    LPVOID a2),
                  GetBitmapBits);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetBitmapDimensionEx(HBITMAP a0,
                                                           struct tagSIZE* a1),
                  GetBitmapDimensionEx);

DETOUR_TRAMPOLINE(COLORREF __stdcall Real_GetBkColor(HDC a0),
                  GetBkColor);

DETOUR_TRAMPOLINE(int __stdcall Real_GetBkMode(HDC a0),
                  GetBkMode);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetBoundsRect(HDC a0,
                                                    LPRECT a1,
                                                    UINT a2),
                  GetBoundsRect);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetBrushOrgEx(HDC a0,
                                                    struct tagPOINT* a1),
                  GetBrushOrgEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCPInfo(UINT a0,
                                                struct _cpinfo* a1),
                  GetCPInfo);

DETOUR_TRAMPOLINE(HWND __stdcall Real_GetCapture(void),
                  GetCapture);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetCaretBlinkTime(void),
                  GetCaretBlinkTime);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCaretPos(struct tagPOINT* a0),
                  GetCaretPos);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCharABCWidthsA(HDC a0,
                                                        UINT a1,
                                                        UINT a2,
                                                        struct _ABC* a3),
                  GetCharABCWidthsA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCharABCWidthsFloatA(HDC a0,
                                                             UINT a1,
                                                             UINT a2,
                                                             struct _ABCFLOAT* a3),
                  GetCharABCWidthsFloatA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCharABCWidthsFloatW(HDC a0,
                                                             UINT a1,
                                                             UINT a2,
                                                             struct _ABCFLOAT* a3),
                  GetCharABCWidthsFloatW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCharABCWidthsW(HDC a0,
                                                        UINT a1,
                                                        UINT a2,
                                                        struct _ABC* a3),
                  GetCharABCWidthsW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCharWidth32A(HDC a0,
                                                      UINT a1,
                                                      UINT a2,
                                                      LPINT a3),
                  GetCharWidth32A);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCharWidth32W(HDC a0,
                                                      UINT a1,
                                                      UINT a2,
                                                      LPINT a3),
                  GetCharWidth32W);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCharWidthA(HDC a0,
                                                    UINT a1,
                                                    UINT a2,
                                                    LPINT a3),
                  GetCharWidthA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCharWidthFloatA(HDC a0,
                                                         UINT a1,
                                                         UINT a2,
                                                         PFLOAT a3),
                  GetCharWidthFloatA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCharWidthFloatW(HDC a0,
                                                         UINT a1,
                                                         UINT a2,
                                                         PFLOAT a3),
                  GetCharWidthFloatW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCharWidthW(HDC a0,
                                                    UINT a1,
                                                    UINT a2,
                                                    LPINT a3),
                  GetCharWidthW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetCharacterPlacementA(HDC a0,
                                                              LPCSTR a1,
                                                              int a2,
                                                              int a3,
                                                              LPGCP_RESULTSA a4,
                                                              DWORD a5),
                  GetCharacterPlacementA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetCharacterPlacementW(HDC a0,
                                                              LPCWSTR a1,
                                                              int a2,
                                                              int a3,
                                                              LPGCP_RESULTSW a4,
                                                              DWORD a5),
                  GetCharacterPlacementW);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_GetClassFile(LPCOLESTR a0,
                                                      CLSID* a1),
                  GetClassFile);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetClassInfoA(HINSTANCE a0,
                                                    LPCSTR a1,
                                                    LPWNDCLASSA a2),
                  GetClassInfoA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetClassInfoExA(HINSTANCE a0,
                                                      LPCSTR a1,
                                                      LPWNDCLASSEXA a2),
                  GetClassInfoExA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetClassInfoExW(HINSTANCE a0,
                                                      LPCWSTR a1,
                                                      LPWNDCLASSEXW a2),
                  GetClassInfoExW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetClassInfoW(HINSTANCE a0,
                                                    LPCWSTR a1,
                                                    LPWNDCLASSW a2),
                  GetClassInfoW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetClassLongA(HWND a0,
                                                     int a1),
                  GetClassLongA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetClassLongW(HWND a0,
                                                     int a1),
                  GetClassLongW);

DETOUR_TRAMPOLINE(int __stdcall Real_GetClassNameA(HWND a0,
                                                   LPSTR a1,
                                                   int a2),
                  GetClassNameA);

DETOUR_TRAMPOLINE(int __stdcall Real_GetClassNameW(HWND a0,
                                                   LPWSTR a1,
                                                   int a2),
                  GetClassNameW);

DETOUR_TRAMPOLINE(WORD __stdcall Real_GetClassWord(HWND a0,
                                                   int a1),
                  GetClassWord);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetClientRect(HWND a0,
                                                    LPRECT a1),
                  GetClientRect);

DETOUR_TRAMPOLINE(int __stdcall Real_GetClipBox(HDC a0,
                                                LPRECT a1),
                  GetClipBox);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetClipCursor(LPRECT a0),
                  GetClipCursor);

DETOUR_TRAMPOLINE(int __stdcall Real_GetClipRgn(HDC a0,
                                                HRGN a1),
                  GetClipRgn);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_GetClipboardData(UINT a0),
                  GetClipboardData);

DETOUR_TRAMPOLINE(int __stdcall Real_GetClipboardFormatNameA(UINT a0,
                                                             LPSTR a1,
                                                             int a2),
                  GetClipboardFormatNameA);

DETOUR_TRAMPOLINE(int __stdcall Real_GetClipboardFormatNameW(UINT a0,
                                                             LPWSTR a1,
                                                             int a2),
                  GetClipboardFormatNameW);

DETOUR_TRAMPOLINE(HWND __stdcall Real_GetClipboardOwner(void),
                  GetClipboardOwner);

DETOUR_TRAMPOLINE(HWND __stdcall Real_GetClipboardViewer(void),
                  GetClipboardViewer);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetColorAdjustment(HDC a0,
                                                         LPCOLORADJUSTMENT a1),
                  GetColorAdjustment);

DETOUR_TRAMPOLINE(HCOLORSPACE __stdcall Real_GetColorSpace(HDC a0),
                  GetColorSpace);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCommConfig(HANDLE a0,
                                                    LPCOMMCONFIG a1,
                                                    LPDWORD a2),
                  GetCommConfig);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCommMask(HANDLE a0,
                                                  LPDWORD a1),
                  GetCommMask);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCommModemStatus(HANDLE a0,
                                                         LPDWORD a1),
                  GetCommModemStatus);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCommProperties(HANDLE a0,
                                                        LPCOMMPROP a1),
                  GetCommProperties);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCommState(HANDLE a0,
                                                   struct _DCB* a1),
                  GetCommState);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCommTimeouts(HANDLE a0,
                                                      struct _COMMTIMEOUTS* a1),
                  GetCommTimeouts);

DETOUR_TRAMPOLINE(LPSTR __stdcall Real_GetCommandLineA(void),
                  GetCommandLineA);

DETOUR_TRAMPOLINE(LPWSTR __stdcall Real_GetCommandLineW(void),
                  GetCommandLineW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetCompressedFileSizeA(LPCSTR a0,
                                                              LPDWORD a1),
                  GetCompressedFileSizeA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetCompressedFileSizeW(LPCWSTR a0,
                                                              LPDWORD a1),
                  GetCompressedFileSizeW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetComputerNameA(LPSTR a0,
                                                       LPDWORD a1),
                  GetComputerNameA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetComputerNameW(LPWSTR a0,
                                                       LPDWORD a1),
                  GetComputerNameW);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetConsoleCP(void),
                  GetConsoleCP);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetConsoleCursorInfo(HANDLE a0,
                                                           PCONSOLE_CURSOR_INFO a1),
                  GetConsoleCursorInfo);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetConsoleMode(HANDLE a0,
                                                     LPDWORD a1),
                  GetConsoleMode);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetConsoleOutputCP(void),
                  GetConsoleOutputCP);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetConsoleScreenBufferInfo(HANDLE a0,
                                                                 PCONSOLE_SCREEN_BUFFER_INFO a1),
                  GetConsoleScreenBufferInfo);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetConsoleTitleA(LPSTR a0,
                                                        DWORD a1),
                  GetConsoleTitleA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetConsoleTitleW(LPWSTR a0,
                                                        DWORD a1),
                  GetConsoleTitleW);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_GetConvertStg(struct IStorage* a0),
                  GetConvertStg);

DETOUR_TRAMPOLINE(int __stdcall Real_GetCurrencyFormatA(LCID a0,
                                                        DWORD a1,
                                                        LPCSTR a2,
                                                        struct _currencyfmtA* a3,
                                                        LPSTR a4,
                                                        int a5),
                  GetCurrencyFormatA);

DETOUR_TRAMPOLINE(int __stdcall Real_GetCurrencyFormatW(LCID a0,
                                                        DWORD a1,
                                                        LPCWSTR a2,
                                                        struct _currencyfmtW* a3,
                                                        LPWSTR a4,
                                                        int a5),
                  GetCurrencyFormatW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetCurrentDirectoryA(DWORD a0,
                                                            LPSTR a1),
                  GetCurrentDirectoryA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetCurrentDirectoryW(DWORD a0,
                                                            LPWSTR a1),
                  GetCurrentDirectoryW);

DETOUR_TRAMPOLINE(HGDIOBJ __stdcall Real_GetCurrentObject(HDC a0,
                                                          UINT a1),
                  GetCurrentObject);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCurrentPositionEx(HDC a0,
                                                           struct tagPOINT* a1),
                  GetCurrentPositionEx);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_GetCurrentProcess(void),
                  GetCurrentProcess);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetCurrentProcessId(void),
                  GetCurrentProcessId);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetCurrentThreadId(void),
                  GetCurrentThreadId);

DETOUR_TRAMPOLINE(HCURSOR __stdcall Real_GetCursor(void),
                  GetCursor);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetCursorPos(struct tagPOINT* a0),
                  GetCursorPos);

DETOUR_TRAMPOLINE(HDC __stdcall Real_GetDC(HWND a0),
                  GetDC);

DETOUR_TRAMPOLINE(HDC __stdcall Real_GetDCEx(HWND a0,
                                             HRGN a1,
                                             DWORD a2),
                  GetDCEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetDCOrgEx(HDC a0,
                                                 struct tagPOINT* a1),
                  GetDCOrgEx);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetDIBColorTable(HDC a0,
                                                       UINT a1,
                                                       UINT a2,
                                                       RGBQUAD* a3),
                  GetDIBColorTable);

DETOUR_TRAMPOLINE(int __stdcall Real_GetDIBits(HDC a0,
                                               HBITMAP a1,
                                               UINT a2,
                                               UINT a3,
                                               LPVOID a4,
                                               LPBITMAPINFO a5,
                                               UINT a6),
                  GetDIBits);

DETOUR_TRAMPOLINE(int __stdcall Real_GetDateFormatA(LCID a0,
                                                    DWORD a1,
                                                    SYSTEMTIME* a2,
                                                    LPCSTR a3,
                                                    LPSTR a4,
                                                    int a5),
                  GetDateFormatA);

DETOUR_TRAMPOLINE(int __stdcall Real_GetDateFormatW(LCID a0,
                                                    DWORD a1,
                                                    SYSTEMTIME* a2,
                                                    LPCWSTR a3,
                                                    LPWSTR a4,
                                                    int a5),
                  GetDateFormatW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetDefaultCommConfigA(LPCSTR a0,
                                                            LPCOMMCONFIG a1,
                                                            LPDWORD a2),
                  GetDefaultCommConfigA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetDefaultCommConfigW(LPCWSTR a0,
                                                            LPCOMMCONFIG a1,
                                                            LPDWORD a2),
                  GetDefaultCommConfigW);

DETOUR_TRAMPOLINE(HWND __stdcall Real_GetDesktopWindow(void),
                  GetDesktopWindow);

DETOUR_TRAMPOLINE(int __stdcall Real_GetDeviceCaps(HDC a0,
                                                   int a1),
                  GetDeviceCaps);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetDeviceGammaRamp(HDC a0,
                                                         LPVOID a1),
                  GetDeviceGammaRamp);

DETOUR_TRAMPOLINE(long __stdcall Real_GetDialogBaseUnits(void),
                  GetDialogBaseUnits);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetDiskFreeSpaceA(LPCSTR a0,
                                                        LPDWORD a1,
                                                        LPDWORD a2,
                                                        LPDWORD a3,
                                                        LPDWORD a4),
                  GetDiskFreeSpaceA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetDiskFreeSpaceExA(LPCSTR a0,
                                                          union _ULARGE_INTEGER* a1,
                                                          union _ULARGE_INTEGER* a2,
                                                          union _ULARGE_INTEGER* a3),
                  GetDiskFreeSpaceExA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetDiskFreeSpaceExW(LPCWSTR a0,
                                                          union _ULARGE_INTEGER* a1,
                                                          union _ULARGE_INTEGER* a2,
                                                          union _ULARGE_INTEGER* a3),
                  GetDiskFreeSpaceExW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetDiskFreeSpaceW(LPCWSTR a0,
                                                        LPDWORD a1,
                                                        LPDWORD a2,
                                                        LPDWORD a3,
                                                        LPDWORD a4),
                  GetDiskFreeSpaceW);

DETOUR_TRAMPOLINE(int __stdcall Real_GetDlgCtrlID(HWND a0),
                  GetDlgCtrlID);

DETOUR_TRAMPOLINE(HWND __stdcall Real_GetDlgItem(HWND a0,
                                                 int a1),
                  GetDlgItem);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetDlgItemInt(HWND a0,
                                                    int a1,
                                                    BOOL* a2,
                                                    BOOL a3),
                  GetDlgItemInt);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetDlgItemTextA(HWND a0,
                                                      int a1,
                                                      LPSTR a2,
                                                      int a3),
                  GetDlgItemTextA);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetDlgItemTextW(HWND a0,
                                                      int a1,
                                                      LPWSTR a2,
                                                      int a3),
                  GetDlgItemTextW);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetDoubleClickTime(void),
                  GetDoubleClickTime);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetDriveTypeA(LPCSTR a0),
                  GetDriveTypeA);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetDriveTypeW(LPCWSTR a0),
                  GetDriveTypeW);

DETOUR_TRAMPOLINE(HENHMETAFILE __stdcall Real_GetEnhMetaFileA(LPCSTR a0),
                  GetEnhMetaFileA);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetEnhMetaFileBits(HENHMETAFILE a0,
                                                         UINT a1,
                                                         LPBYTE a2),
                  GetEnhMetaFileBits);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetEnhMetaFileDescriptionA(HENHMETAFILE a0,
                                                                 UINT a1,
                                                                 LPSTR a2),
                  GetEnhMetaFileDescriptionA);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetEnhMetaFileDescriptionW(HENHMETAFILE a0,
                                                                 UINT a1,
                                                                 LPWSTR a2),
                  GetEnhMetaFileDescriptionW);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetEnhMetaFileHeader(HENHMETAFILE a0,
                                                           UINT a1,
                                                           struct tagENHMETAHEADER* a2),
                  GetEnhMetaFileHeader);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetEnhMetaFilePaletteEntries(HENHMETAFILE a0,
                                                                   UINT a1,
                                                                   struct tagPALETTEENTRY* a2),
                  GetEnhMetaFilePaletteEntries);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetEnhMetaFilePixelFormat(HENHMETAFILE a0,
                                                                UINT a1,
                                                                PIXELFORMATDESCRIPTOR* a2),
                  GetEnhMetaFilePixelFormat);

DETOUR_TRAMPOLINE(HENHMETAFILE __stdcall Real_GetEnhMetaFileW(LPCWSTR a0),
                  GetEnhMetaFileW);

DETOUR_TRAMPOLINE(LPSTR __stdcall Real_GetEnvironmentStrings(void),
                  GetEnvironmentStrings);

DETOUR_TRAMPOLINE(LPWSTR __stdcall Real_GetEnvironmentStringsW(void),
                  GetEnvironmentStringsW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetEnvironmentVariableA(LPCSTR a0,
                                                               LPSTR a1,
                                                               DWORD a2),
                  GetEnvironmentVariableA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetEnvironmentVariableW(LPCWSTR a0,
                                                               LPWSTR a1,
                                                               DWORD a2),
                  GetEnvironmentVariableW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetExitCodeProcess(HANDLE a0,
                                                         LPDWORD a1),
                  GetExitCodeProcess);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetExitCodeThread(HANDLE a0,
                                                        LPDWORD a1),
                  GetExitCodeThread);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetFileAttributesA(LPCSTR a0),
                  GetFileAttributesA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetFileAttributesExA(LPCSTR a0,
                                                           enum _GET_FILEEX_INFO_LEVELS a1,
                                                           LPVOID a2),
                  GetFileAttributesExA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetFileAttributesExW(LPCWSTR a0,
                                                           enum _GET_FILEEX_INFO_LEVELS a1,
                                                           LPVOID a2),
                  GetFileAttributesExW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetFileAttributesW(LPCWSTR a0),
                  GetFileAttributesW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetFileInformationByHandle(HANDLE a0,
                                                                 struct _BY_HANDLE_FILE_INFORMATION* a1),
                  GetFileInformationByHandle);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetFileSize(HANDLE a0,
                                                   LPDWORD a1),
                  GetFileSize);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetFileTime(HANDLE a0,
                                                  LPFILETIME a1,
                                                  LPFILETIME a2,
                                                  LPFILETIME a3),
                  GetFileTime);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetFileType(HANDLE a0),
                  GetFileType);

DETOUR_TRAMPOLINE(HWND __stdcall Real_GetFocus(void),
                  GetFocus);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetFontData(HDC a0,
                                                   DWORD a1,
                                                   DWORD a2,
                                                   LPVOID a3,
                                                   DWORD a4),
                  GetFontData);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetFontLanguageInfo(HDC a0),
                  GetFontLanguageInfo);

DETOUR_TRAMPOLINE(HWND __stdcall Real_GetForegroundWindow(void),
                  GetForegroundWindow);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetFullPathNameA(LPCSTR a0,
                                                        DWORD a1,
                                                        LPSTR a2,
                                                        LPSTR* a3),
                  GetFullPathNameA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetFullPathNameW(LPCWSTR a0,
                                                        DWORD a1,
                                                        LPWSTR a2,
                                                        LPWSTR* a3),
                  GetFullPathNameW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetGlyphOutlineA(HDC a0,
                                                        UINT a1,
                                                        UINT a2,
                                                        LPGLYPHMETRICS a3,
                                                        DWORD a4,
                                                        LPVOID a5,
                                                        MAT2* a6),
                  GetGlyphOutlineA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetGlyphOutlineW(HDC a0,
                                                        UINT a1,
                                                        UINT a2,
                                                        LPGLYPHMETRICS a3,
                                                        DWORD a4,
                                                        LPVOID a5,
                                                        MAT2* a6),
                  GetGlyphOutlineW);

DETOUR_TRAMPOLINE(int __stdcall Real_GetGraphicsMode(HDC a0),
                  GetGraphicsMode);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_GetHGlobalFromILockBytes(struct ILockBytes* a0,
                                                                  HGLOBAL* a1),
                  GetHGlobalFromILockBytes);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_GetHGlobalFromStream(LPSTREAM a0,
                                                              HGLOBAL* a1),
                  GetHGlobalFromStream);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetHandleInformation(HANDLE a0,
                                                           LPDWORD a1),
                  GetHandleInformation);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetICMProfileA(HDC a0,
                                                     LPDWORD a1,
                                                     LPSTR a2),
                  GetICMProfileA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetICMProfileW(HDC a0,
                                                     LPDWORD a1,
                                                     LPWSTR a2),
                  GetICMProfileW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetIconInfo(HICON a0,
                                                  struct _ICONINFO* a1),
                  GetIconInfo);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetInputState(void),
                  GetInputState);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetKBCodePage(void),
                  GetKBCodePage);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetKerningPairsA(HDC a0,
                                                        DWORD a1,
                                                        struct tagKERNINGPAIR* a2),
                  GetKerningPairsA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetKerningPairsW(HDC a0,
                                                        DWORD a1,
                                                        struct tagKERNINGPAIR* a2),
                  GetKerningPairsW);

DETOUR_TRAMPOLINE(int __stdcall Real_GetKeyNameTextA(LONG a0,
                                                     LPSTR a1,
                                                     int a2),
                  GetKeyNameTextA);

DETOUR_TRAMPOLINE(int __stdcall Real_GetKeyNameTextW(LONG a0,
                                                     LPWSTR a1,
                                                     int a2),
                  GetKeyNameTextW);

DETOUR_TRAMPOLINE(SHORT __stdcall Real_GetKeyState(int a0),
                  GetKeyState);

DETOUR_TRAMPOLINE(HKL __stdcall Real_GetKeyboardLayout(DWORD a0),
                  GetKeyboardLayout);

DETOUR_TRAMPOLINE(int __stdcall Real_GetKeyboardLayoutList(int a0,
                                                           HKL* a1),
                  GetKeyboardLayoutList);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetKeyboardLayoutNameA(LPSTR a0),
                  GetKeyboardLayoutNameA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetKeyboardLayoutNameW(LPWSTR a0),
                  GetKeyboardLayoutNameW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetKeyboardState(PBYTE a0),
                  GetKeyboardState);

DETOUR_TRAMPOLINE(int __stdcall Real_GetKeyboardType(int a0),
                  GetKeyboardType);

DETOUR_TRAMPOLINE(HWND __stdcall Real_GetLastActivePopup(HWND a0),
                  GetLastActivePopup);

DETOUR_TRAMPOLINE(void __stdcall Real_GetLocalTime(struct _SYSTEMTIME* a0),
                  GetLocalTime);

DETOUR_TRAMPOLINE(int __stdcall Real_GetLocaleInfoA(LCID a0,
                                                    LCTYPE a1,
                                                    LPSTR a2,
                                                    int a3),
                  GetLocaleInfoA);

DETOUR_TRAMPOLINE(int __stdcall Real_GetLocaleInfoW(LCID a0,
                                                    LCTYPE a1,
                                                    LPWSTR a2,
                                                    int a3),
                  GetLocaleInfoW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetLogColorSpaceA(HCOLORSPACE a0,
                                                        struct tagLOGCOLORSPACEA* a1,
                                                        DWORD a2),
                  GetLogColorSpaceA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetLogColorSpaceW(HCOLORSPACE a0,
                                                        struct tagLOGCOLORSPACEW* a1,
                                                        DWORD a2),
                  GetLogColorSpaceW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetLogicalDriveStringsA(DWORD a0,
                                                               LPSTR a1),
                  GetLogicalDriveStringsA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetLogicalDriveStringsW(DWORD a0,
                                                               LPWSTR a1),
                  GetLogicalDriveStringsW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetLogicalDrives(void),
                  GetLogicalDrives);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetMailslotInfo(HANDLE a0,
                                                      LPDWORD a1,
                                                      LPDWORD a2,
                                                      LPDWORD a3,
                                                      LPDWORD a4),
                  GetMailslotInfo);

DETOUR_TRAMPOLINE(int __stdcall Real_GetMapMode(HDC a0),
                  GetMapMode);

DETOUR_TRAMPOLINE(HMENU __stdcall Real_GetMenu(HWND a0),
                  GetMenu);

DETOUR_TRAMPOLINE(LONG __stdcall Real_GetMenuCheckMarkDimensions(void),
                  GetMenuCheckMarkDimensions);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetMenuContextHelpId(HMENU a0),
                  GetMenuContextHelpId);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetMenuDefaultItem(HMENU a0,
                                                         UINT a1,
                                                         UINT a2),
                  GetMenuDefaultItem);

DETOUR_TRAMPOLINE(int __stdcall Real_GetMenuItemCount(HMENU a0),
                  GetMenuItemCount);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetMenuItemID(HMENU a0,
                                                    int a1),
                  GetMenuItemID);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetMenuItemInfoA(HMENU a0,
                                                       UINT a1,
                                                       BOOL a2,
                                                       LPMENUITEMINFOA a3),
                  GetMenuItemInfoA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetMenuItemInfoW(HMENU a0,
                                                       UINT a1,
                                                       BOOL a2,
                                                       LPMENUITEMINFOW a3),
                  GetMenuItemInfoW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetMenuItemRect(HWND a0,
                                                      HMENU a1,
                                                      UINT a2,
                                                      LPRECT a3),
                  GetMenuItemRect);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetMenuState(HMENU a0,
                                                   UINT a1,
                                                   UINT a2),
                  GetMenuState);

DETOUR_TRAMPOLINE(int __stdcall Real_GetMenuStringA(HMENU a0,
                                                    UINT a1,
                                                    LPSTR a2,
                                                    int a3,
                                                    UINT a4),
                  GetMenuStringA);

DETOUR_TRAMPOLINE(int __stdcall Real_GetMenuStringW(HMENU a0,
                                                    UINT a1,
                                                    LPWSTR a2,
                                                    int a3,
                                                    UINT a4),
                  GetMenuStringW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetMessageA(LPMSG a0,
                                                  HWND a1,
                                                  UINT a2,
                                                  UINT a3),
                  GetMessageA);

DETOUR_TRAMPOLINE(LPARAM __stdcall Real_GetMessageExtraInfo(void),
                  GetMessageExtraInfo);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetMessagePos(void),
                  GetMessagePos);

DETOUR_TRAMPOLINE(LONG __stdcall Real_GetMessageTime(void),
                  GetMessageTime);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetMessageW(LPMSG a0,
                                                  HWND a1,
                                                  UINT a2,
                                                  UINT a3),
                  GetMessageW);

DETOUR_TRAMPOLINE(HMETAFILE __stdcall Real_GetMetaFileA(LPCSTR a0),
                  GetMetaFileA);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetMetaFileBitsEx(HMETAFILE a0,
                                                        UINT a1,
                                                        LPVOID a2),
                  GetMetaFileBitsEx);

DETOUR_TRAMPOLINE(HMETAFILE __stdcall Real_GetMetaFileW(LPCWSTR a0),
                  GetMetaFileW);

DETOUR_TRAMPOLINE(int __stdcall Real_GetMetaRgn(HDC a0,
                                                HRGN a1),
                  GetMetaRgn);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetMiterLimit(HDC a0,
                                                    PFLOAT a1),
                  GetMiterLimit);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetModuleFileNameA(HMODULE a0,
                                                          LPSTR a1,
                                                          DWORD a2),
                  GetModuleFileNameA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetModuleFileNameW(HMODULE a0,
                                                          LPWSTR a1,
                                                          DWORD a2),
                  GetModuleFileNameW);

DETOUR_TRAMPOLINE(HMODULE __stdcall Real_GetModuleHandleA(LPCSTR a0),
                  GetModuleHandleA);

DETOUR_TRAMPOLINE(HMODULE __stdcall Real_GetModuleHandleW(LPCWSTR a0),
                  GetModuleHandleW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetNamedPipeHandleStateA(HANDLE a0,
                                                               LPDWORD a1,
                                                               LPDWORD a2,
                                                               LPDWORD a3,
                                                               LPDWORD a4,
                                                               LPSTR a5,
                                                               DWORD a6),
                  GetNamedPipeHandleStateA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetNamedPipeHandleStateW(HANDLE a0,
                                                               LPDWORD a1,
                                                               LPDWORD a2,
                                                               LPDWORD a3,
                                                               LPDWORD a4,
                                                               LPWSTR a5,
                                                               DWORD a6),
                  GetNamedPipeHandleStateW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetNamedPipeInfo(HANDLE a0,
                                                       LPDWORD a1,
                                                       LPDWORD a2,
                                                       LPDWORD a3,
                                                       LPDWORD a4),
                  GetNamedPipeInfo);

DETOUR_TRAMPOLINE(COLORREF __stdcall Real_GetNearestColor(HDC a0,
                                                          COLORREF a1),
                  GetNearestColor);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetNearestPaletteIndex(HPALETTE a0,
                                                             COLORREF a1),
                  GetNearestPaletteIndex);

DETOUR_TRAMPOLINE(HWND __stdcall Real_GetNextDlgGroupItem(HWND a0,
                                                          HWND a1,
                                                          BOOL a2),
                  GetNextDlgGroupItem);

DETOUR_TRAMPOLINE(HWND __stdcall Real_GetNextDlgTabItem(HWND a0,
                                                        HWND a1,
                                                        BOOL a2),
                  GetNextDlgTabItem);

DETOUR_TRAMPOLINE(int __stdcall Real_GetNumberFormatA(LCID a0,
                                                      DWORD a1,
                                                      LPCSTR a2,
                                                      NUMBERFMTA* a3,
                                                      LPSTR a4,
                                                      int a5),
                  GetNumberFormatA);

DETOUR_TRAMPOLINE(int __stdcall Real_GetNumberFormatW(LCID a0,
                                                      DWORD a1,
                                                      LPCWSTR a2,
                                                      NUMBERFMTW* a3,
                                                      LPWSTR a4,
                                                      int a5),
                  GetNumberFormatW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetNumberOfConsoleInputEvents(HANDLE a0,
                                                                    LPDWORD a1),
                  GetNumberOfConsoleInputEvents);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetNumberOfConsoleMouseButtons(LPDWORD a0),
                  GetNumberOfConsoleMouseButtons);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetOEMCP(void),
                  GetOEMCP);

DETOUR_TRAMPOLINE(int __stdcall Real_GetObjectA(HGDIOBJ a0,
                                                int a1,
                                                LPVOID a2),
                  GetObjectA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetObjectType(HGDIOBJ a0),
                  GetObjectType);

DETOUR_TRAMPOLINE(int __stdcall Real_GetObjectW(HGDIOBJ a0,
                                                int a1,
                                                LPVOID a2),
                  GetObjectW);

DETOUR_TRAMPOLINE(HWND __stdcall Real_GetOpenClipboardWindow(void),
                  GetOpenClipboardWindow);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetOutlineTextMetricsA(HDC a0,
                                                             UINT a1,
                                                             LPOUTLINETEXTMETRICA a2),
                  GetOutlineTextMetricsA);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetOutlineTextMetricsW(HDC a0,
                                                             UINT a1,
                                                             LPOUTLINETEXTMETRICW a2),
                  GetOutlineTextMetricsW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetOverlappedResult(HANDLE a0,
                                                          LPOVERLAPPED a1,
                                                          LPDWORD a2,
                                                          BOOL a3),
                  GetOverlappedResult);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetPaletteEntries(HPALETTE a0,
                                                        UINT a1,
                                                        UINT a2,
                                                        struct tagPALETTEENTRY* a3),
                  GetPaletteEntries);

DETOUR_TRAMPOLINE(HWND __stdcall Real_GetParent(HWND a0),
                  GetParent);

DETOUR_TRAMPOLINE(int __stdcall Real_GetPath(HDC a0,
                                             struct tagPOINT* a1,
                                             LPBYTE a2,
                                             int a3),
                  GetPath);

DETOUR_TRAMPOLINE(COLORREF __stdcall Real_GetPixel(HDC a0,
                                                   int a1,
                                                   int a2),
                  GetPixel);

DETOUR_TRAMPOLINE(int __stdcall Real_GetPixelFormat(HDC a0),
                  GetPixelFormat);

DETOUR_TRAMPOLINE(int __stdcall Real_GetPolyFillMode(HDC a0),
                  GetPolyFillMode);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetPriorityClass(HANDLE a0),
                  GetPriorityClass);

DETOUR_TRAMPOLINE(int __stdcall Real_GetPriorityClipboardFormat(UINT* a0,
                                                                int a1),
                  GetPriorityClipboardFormat);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetPrivateProfileIntA(LPCSTR a0,
                                                            LPCSTR a1,
                                                            INT a2,
                                                            LPCSTR a3),
                  GetPrivateProfileIntA);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetPrivateProfileIntW(LPCWSTR a0,
                                                            LPCWSTR a1,
                                                            INT a2,
                                                            LPCWSTR a3),
                  GetPrivateProfileIntW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetPrivateProfileSectionA(LPCSTR a0,
                                                                 LPSTR a1,
                                                                 DWORD a2,
                                                                 LPCSTR a3),
                  GetPrivateProfileSectionA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetPrivateProfileSectionNamesA(LPSTR a0,
                                                                      DWORD a1,
                                                                      LPCSTR a2),
                  GetPrivateProfileSectionNamesA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetPrivateProfileSectionNamesW(LPWSTR a0,
                                                                      DWORD a1,
                                                                      LPCWSTR a2),
                  GetPrivateProfileSectionNamesW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetPrivateProfileSectionW(LPCWSTR a0,
                                                                 LPWSTR a1,
                                                                 DWORD a2,
                                                                 LPCWSTR a3),
                  GetPrivateProfileSectionW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetPrivateProfileStringA(LPCSTR a0,
                                                                LPCSTR a1,
                                                                LPCSTR a2,
                                                                LPSTR a3,
                                                                DWORD a4,
                                                                LPCSTR a5),
                  GetPrivateProfileStringA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetPrivateProfileStringW(LPCWSTR a0,
                                                                LPCWSTR a1,
                                                                LPCWSTR a2,
                                                                LPWSTR a3,
                                                                DWORD a4,
                                                                LPCWSTR a5),
                  GetPrivateProfileStringW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetPrivateProfileStructA(LPCSTR a0,
                                                               LPCSTR a1,
                                                               LPVOID a2,
                                                               UINT a3,
                                                               LPCSTR a4),
                  GetPrivateProfileStructA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetPrivateProfileStructW(LPCWSTR a0,
                                                               LPCWSTR a1,
                                                               LPVOID a2,
                                                               UINT a3,
                                                               LPCWSTR a4),
                  GetPrivateProfileStructW);

DETOUR_TRAMPOLINE(FARPROC __stdcall Real_GetProcAddress(HMODULE a0,
                                                        LPCSTR a1),
                  GetProcAddress);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetProcessAffinityMask(HANDLE a0,
                                                             LPDWORD a1,
                                                             LPDWORD a2),
                  GetProcessAffinityMask);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetProcessHeaps(DWORD a0,
                                                       PHANDLE a1),
                  GetProcessHeaps);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetProcessPriorityBoost(HANDLE a0,
                                                              PBOOL a1),
                  GetProcessPriorityBoost);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetProcessShutdownParameters(LPDWORD a0,
                                                                   LPDWORD a1),
                  GetProcessShutdownParameters);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetProcessTimes(HANDLE a0,
                                                      LPFILETIME a1,
                                                      LPFILETIME a2,
                                                      LPFILETIME a3,
                                                      LPFILETIME a4),
                  GetProcessTimes);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetProcessVersion(DWORD a0),
                  GetProcessVersion);

DETOUR_TRAMPOLINE(HWINSTA __stdcall Real_GetProcessWindowStation(void),
                  GetProcessWindowStation);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetProcessWorkingSetSize(HANDLE a0,
                                                               PSIZE_T a1,
                                                               PSIZE_T a2),
                  GetProcessWorkingSetSize);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetProfileIntA(LPCSTR a0,
                                                     LPCSTR a1,
                                                     INT a2),
                  GetProfileIntA);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetProfileIntW(LPCWSTR a0,
                                                     LPCWSTR a1,
                                                     INT a2),
                  GetProfileIntW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetProfileSectionA(LPCSTR a0,
                                                          LPSTR a1,
                                                          DWORD a2),
                  GetProfileSectionA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetProfileSectionW(LPCWSTR a0,
                                                          LPWSTR a1,
                                                          DWORD a2),
                  GetProfileSectionW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetProfileStringA(LPCSTR a0,
                                                         LPCSTR a1,
                                                         LPCSTR a2,
                                                         LPSTR a3,
                                                         DWORD a4),
                  GetProfileStringA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetProfileStringW(LPCWSTR a0,
                                                         LPCWSTR a1,
                                                         LPCWSTR a2,
                                                         LPWSTR a3,
                                                         DWORD a4),
                  GetProfileStringW);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_GetPropA(HWND a0,
                                                 LPCSTR a1),
                  GetPropA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_GetPropW(HWND a0,
                                                 LPCWSTR a1),
                  GetPropW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetQueueStatus(UINT a0),
                  GetQueueStatus);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetQueuedCompletionStatus(HANDLE a0,
                                                                LPDWORD a1,
                                                                PULONG_PTR a2,
                                                                LPOVERLAPPED* a3,
                                                                DWORD a4),
                  GetQueuedCompletionStatus);

DETOUR_TRAMPOLINE(int __stdcall Real_GetROP2(HDC a0),
                  GetROP2);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetRasterizerCaps(LPRASTERIZER_STATUS a0,
                                                        UINT a1),
                  GetRasterizerCaps);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetRegionData(HRGN a0,
                                                     DWORD a1,
                                                     LPRGNDATA a2),
                  GetRegionData);

DETOUR_TRAMPOLINE(int __stdcall Real_GetRgnBox(HRGN a0,
                                               LPRECT a1),
                  GetRgnBox);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_GetRunningObjectTable(DWORD a0,
                                                               LPRUNNINGOBJECTTABLE* a1),
                  GetRunningObjectTable);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetScrollInfo(HWND a0,
                                                    int a1,
                                                    LPSCROLLINFO a2),
                  GetScrollInfo);

DETOUR_TRAMPOLINE(int __stdcall Real_GetScrollPos(HWND a0,
                                                  int a1),
                  GetScrollPos);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetScrollRange(HWND a0,
                                                     int a1,
                                                     LPINT a2,
                                                     LPINT a3),
                  GetScrollRange);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetShortPathNameA(LPCSTR a0,
                                                         LPSTR a1,
                                                         DWORD a2),
                  GetShortPathNameA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetShortPathNameW(LPCWSTR a0,
                                                         LPWSTR a1,
                                                         DWORD a2),
                  GetShortPathNameW);

DETOUR_TRAMPOLINE(void __stdcall Real_GetStartupInfoA(struct _STARTUPINFOA* a0),
                  GetStartupInfoA);

DETOUR_TRAMPOLINE(void __stdcall Real_GetStartupInfoW(struct _STARTUPINFOW* a0),
                  GetStartupInfoW);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_GetStdHandle(DWORD a0),
                  GetStdHandle);

DETOUR_TRAMPOLINE(HGDIOBJ __stdcall Real_GetStockObject(int a0),
                  GetStockObject);

DETOUR_TRAMPOLINE(int __stdcall Real_GetStretchBltMode(HDC a0),
                  GetStretchBltMode);

DETOUR_TRAMPOLINE(HMENU __stdcall Real_GetSubMenu(HMENU a0,
                                                  int a1),
                  GetSubMenu);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetSysColor(int a0),
                  GetSysColor);

DETOUR_TRAMPOLINE(HBRUSH __stdcall Real_GetSysColorBrush(int a0),
                  GetSysColorBrush);

DETOUR_TRAMPOLINE(LCID __stdcall Real_GetSystemDefaultLCID(void),
                  GetSystemDefaultLCID);

DETOUR_TRAMPOLINE(LANGID __stdcall Real_GetSystemDefaultLangID(void),
                  GetSystemDefaultLangID);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetSystemDirectoryA(LPSTR a0,
                                                          UINT a1),
                  GetSystemDirectoryA);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetSystemDirectoryW(LPWSTR a0,
                                                          UINT a1),
                  GetSystemDirectoryW);

DETOUR_TRAMPOLINE(void __stdcall Real_GetSystemInfo(struct _SYSTEM_INFO* a0),
                  GetSystemInfo);

DETOUR_TRAMPOLINE(HMENU __stdcall Real_GetSystemMenu(HWND a0,
                                                     BOOL a1),
                  GetSystemMenu);

DETOUR_TRAMPOLINE(int __stdcall Real_GetSystemMetrics(int a0),
                  GetSystemMetrics);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetSystemPaletteEntries(HDC a0,
                                                              UINT a1,
                                                              UINT a2,
                                                              struct tagPALETTEENTRY* a3),
                  GetSystemPaletteEntries);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetSystemPaletteUse(HDC a0),
                  GetSystemPaletteUse);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetSystemPowerStatus(LPSYSTEM_POWER_STATUS a0),
                  GetSystemPowerStatus);

DETOUR_TRAMPOLINE(void __stdcall Real_GetSystemTime(struct _SYSTEMTIME* a0),
                  GetSystemTime);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetSystemTimeAdjustment(PDWORD a0,
                                                              PDWORD a1,
                                                              PBOOL a2),
                  GetSystemTimeAdjustment);

DETOUR_TRAMPOLINE(void __stdcall Real_GetSystemTimeAsFileTime(LPFILETIME a0),
                  GetSystemTimeAsFileTime);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetTabbedTextExtentA(HDC a0,
                                                            LPCSTR a1,
                                                            int a2,
                                                            int a3,
                                                            INT* a4),
                  GetTabbedTextExtentA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetTabbedTextExtentW(HDC a0,
                                                            LPCWSTR a1,
                                                            int a2,
                                                            int a3,
                                                            INT* a4),
                  GetTabbedTextExtentW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetTapeParameters(HANDLE a0,
                                                         DWORD a1,
                                                         LPDWORD a2,
                                                         LPVOID a3),
                  GetTapeParameters);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetTapePosition(HANDLE a0,
                                                       DWORD a1,
                                                       LPDWORD a2,
                                                       LPDWORD a3,
                                                       LPDWORD a4),
                  GetTapePosition);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetTapeStatus(HANDLE a0),
                  GetTapeStatus);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetTempFileNameA(LPCSTR a0,
                                                       LPCSTR a1,
                                                       UINT a2,
                                                       LPSTR a3),
                  GetTempFileNameA);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetTempFileNameW(LPCWSTR a0,
                                                       LPCWSTR a1,
                                                       UINT a2,
                                                       LPWSTR a3),
                  GetTempFileNameW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetTempPathA(DWORD a0,
                                                    LPSTR a1),
                  GetTempPathA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetTempPathW(DWORD a0,
                                                    LPWSTR a1),
                  GetTempPathW);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetTextAlign(HDC a0),
                  GetTextAlign);

DETOUR_TRAMPOLINE(int __stdcall Real_GetTextCharacterExtra(HDC a0),
                  GetTextCharacterExtra);

DETOUR_TRAMPOLINE(int __stdcall Real_GetTextCharset(HDC a0),
                  GetTextCharset);

DETOUR_TRAMPOLINE(int __stdcall Real_GetTextCharsetInfo(HDC a0,
                                                        LPFONTSIGNATURE a1,
                                                        DWORD a2),
                  GetTextCharsetInfo);

DETOUR_TRAMPOLINE(COLORREF __stdcall Real_GetTextColor(HDC a0),
                  GetTextColor);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetTextExtentExPointA(HDC a0,
                                                            LPCSTR a1,
                                                            int a2,
                                                            int a3,
                                                            LPINT a4,
                                                            LPINT a5,
                                                            struct tagSIZE* a6),
                  GetTextExtentExPointA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetTextExtentExPointW(HDC a0,
                                                            LPCWSTR a1,
                                                            int a2,
                                                            int a3,
                                                            LPINT a4,
                                                            LPINT a5,
                                                            struct tagSIZE* a6),
                  GetTextExtentExPointW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetTextExtentPoint32A(HDC a0,
                                                            LPCSTR a1,
                                                            int a2,
                                                            struct tagSIZE* a3),
                  GetTextExtentPoint32A);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetTextExtentPoint32W(HDC a0,
                                                            LPCWSTR a1,
                                                            int a2,
                                                            struct tagSIZE* a3),
                  GetTextExtentPoint32W);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetTextExtentPointA(HDC a0,
                                                          LPCSTR a1,
                                                          int a2,
                                                          struct tagSIZE* a3),
                  GetTextExtentPointA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetTextExtentPointW(HDC a0,
                                                          LPCWSTR a1,
                                                          int a2,
                                                          struct tagSIZE* a3),
                  GetTextExtentPointW);

DETOUR_TRAMPOLINE(int __stdcall Real_GetTextFaceA(HDC a0,
                                                  int a1,
                                                  LPSTR a2),
                  GetTextFaceA);

DETOUR_TRAMPOLINE(int __stdcall Real_GetTextFaceW(HDC a0,
                                                  int a1,
                                                  LPWSTR a2),
                  GetTextFaceW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetTextMetricsA(HDC a0,
                                                      LPTEXTMETRICA a1),
                  GetTextMetricsA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetTextMetricsW(HDC a0,
                                                      LPTEXTMETRICW a1),
                  GetTextMetricsW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetThreadContext(HANDLE a0,
                                                       LPCONTEXT a1),
                  GetThreadContext);

DETOUR_TRAMPOLINE(HDESK __stdcall Real_GetThreadDesktop(DWORD a0),
                  GetThreadDesktop);

DETOUR_TRAMPOLINE(LCID __stdcall Real_GetThreadLocale(void),
                  GetThreadLocale);

DETOUR_TRAMPOLINE(int __stdcall Real_GetThreadPriority(HANDLE a0),
                  GetThreadPriority);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetThreadPriorityBoost(HANDLE a0,
                                                             PBOOL a1),
                  GetThreadPriorityBoost);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetThreadSelectorEntry(HANDLE a0,
                                                             DWORD a1,
                                                             struct _LDT_ENTRY* a2),
                  GetThreadSelectorEntry);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetThreadTimes(HANDLE a0,
                                                     LPFILETIME a1,
                                                     LPFILETIME a2,
                                                     LPFILETIME a3,
                                                     LPFILETIME a4),
                  GetThreadTimes);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetTickCount(void),
                  GetTickCount);

DETOUR_TRAMPOLINE(int __stdcall Real_GetTimeFormatA(LCID a0,
                                                    DWORD a1,
                                                    SYSTEMTIME* a2,
                                                    LPCSTR a3,
                                                    LPSTR a4,
                                                    int a5),
                  GetTimeFormatA);

DETOUR_TRAMPOLINE(int __stdcall Real_GetTimeFormatW(LCID a0,
                                                    DWORD a1,
                                                    SYSTEMTIME* a2,
                                                    LPCWSTR a3,
                                                    LPWSTR a4,
                                                    int a5),
                  GetTimeFormatW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetTimeZoneInformation(struct _TIME_ZONE_INFORMATION* a0),
                  GetTimeZoneInformation);

DETOUR_TRAMPOLINE(HWND __stdcall Real_GetTopWindow(HWND a0),
                  GetTopWindow);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetUpdateRect(HWND a0,
                                                    LPRECT a1,
                                                    BOOL a2),
                  GetUpdateRect);

DETOUR_TRAMPOLINE(int __stdcall Real_GetUpdateRgn(HWND a0,
                                                  HRGN a1,
                                                  BOOL a2),
                  GetUpdateRgn);

DETOUR_TRAMPOLINE(LCID __stdcall Real_GetUserDefaultLCID(void),
                  GetUserDefaultLCID);

DETOUR_TRAMPOLINE(LANGID __stdcall Real_GetUserDefaultLangID(void),
                  GetUserDefaultLangID);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetUserObjectInformationA(HANDLE a0,
                                                                int a1,
                                                                PVOID a2,
                                                                DWORD a3,
                                                                LPDWORD a4),
                  GetUserObjectInformationA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetUserObjectInformationW(HANDLE a0,
                                                                int a1,
                                                                PVOID a2,
                                                                DWORD a3,
                                                                LPDWORD a4),
                  GetUserObjectInformationW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetUserObjectSecurity(HANDLE a0,
                                                            PSECURITY_INFORMATION a1,
                                                            PSECURITY_DESCRIPTOR a2,
                                                            DWORD a3,
                                                            LPDWORD a4),
                  GetUserObjectSecurity);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetVersion(void),
                  GetVersion);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetVersionExA(LPOSVERSIONINFOA a0),
                  GetVersionExA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetVersionExW(LPOSVERSIONINFOW a0),
                  GetVersionExW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetViewportExtEx(HDC a0,
                                                       struct tagSIZE* a1),
                  GetViewportExtEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetViewportOrgEx(HDC a0,
                                                       struct tagPOINT* a1),
                  GetViewportOrgEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetVolumeInformationA(LPCSTR a0,
                                                            LPSTR a1,
                                                            DWORD a2,
                                                            LPDWORD a3,
                                                            LPDWORD a4,
                                                            LPDWORD a5,
                                                            LPSTR a6,
                                                            DWORD a7),
                  GetVolumeInformationA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetVolumeInformationW(LPCWSTR a0,
                                                            LPWSTR a1,
                                                            DWORD a2,
                                                            LPDWORD a3,
                                                            LPDWORD a4,
                                                            LPDWORD a5,
                                                            LPWSTR a6,
                                                            DWORD a7),
                  GetVolumeInformationW);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetWinMetaFileBits(HENHMETAFILE a0,
                                                         UINT a1,
                                                         LPBYTE a2,
                                                         INT a3,
                                                         HDC a4),
                  GetWinMetaFileBits);

DETOUR_TRAMPOLINE(HWND __stdcall Real_GetWindow(HWND a0,
                                                UINT a1),
                  GetWindow);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetWindowContextHelpId(HWND a0),
                  GetWindowContextHelpId);

DETOUR_TRAMPOLINE(HDC __stdcall Real_GetWindowDC(HWND a0),
                  GetWindowDC);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetWindowExtEx(HDC a0,
                                                     struct tagSIZE* a1),
                  GetWindowExtEx);

DETOUR_TRAMPOLINE(LONG __stdcall Real_GetWindowLongA(HWND a0,
                                                     int a1),
                  GetWindowLongA);

DETOUR_TRAMPOLINE(LONG __stdcall Real_GetWindowLongW(HWND a0,
                                                     int a1),
                  GetWindowLongW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetWindowOrgEx(HDC a0,
                                                     struct tagPOINT* a1),
                  GetWindowOrgEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetWindowPlacement(HWND a0,
                                                         struct tagWINDOWPLACEMENT* a1),
                  GetWindowPlacement);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetWindowRect(HWND a0,
                                                    LPRECT a1),
                  GetWindowRect);

DETOUR_TRAMPOLINE(int __stdcall Real_GetWindowRgn(HWND a0,
                                                  HRGN a1),
                  GetWindowRgn);

DETOUR_TRAMPOLINE(int __stdcall Real_GetWindowTextA(HWND a0,
                                                    LPSTR a1,
                                                    int a2),
                  GetWindowTextA);

DETOUR_TRAMPOLINE(int __stdcall Real_GetWindowTextLengthA(HWND a0),
                  GetWindowTextLengthA);

DETOUR_TRAMPOLINE(int __stdcall Real_GetWindowTextLengthW(HWND a0),
                  GetWindowTextLengthW);

DETOUR_TRAMPOLINE(int __stdcall Real_GetWindowTextW(HWND a0,
                                                    LPWSTR a1,
                                                    int a2),
                  GetWindowTextW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_GetWindowThreadProcessId(HWND a0,
                                                                LPDWORD a1),
                  GetWindowThreadProcessId);

DETOUR_TRAMPOLINE(WORD __stdcall Real_GetWindowWord(HWND a0,
                                                    int a1),
                  GetWindowWord);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetWindowsDirectoryA(LPSTR a0,
                                                           UINT a1),
                  GetWindowsDirectoryA);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GetWindowsDirectoryW(LPWSTR a0,
                                                           UINT a1),
                  GetWindowsDirectoryW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GetWorldTransform(HDC a0,
                                                        struct tagXFORM* a1),
                  GetWorldTransform);

DETOUR_TRAMPOLINE(ATOM __stdcall Real_GlobalAddAtomA(LPCSTR a0),
                  GlobalAddAtomA);

DETOUR_TRAMPOLINE(ATOM __stdcall Real_GlobalAddAtomW(LPCWSTR a0),
                  GlobalAddAtomW);

DETOUR_TRAMPOLINE(HGLOBAL __stdcall Real_GlobalAlloc(UINT a0,
                                                     SIZE_T a1),
                  GlobalAlloc);

DETOUR_TRAMPOLINE(SIZE_T __stdcall Real_GlobalCompact(DWORD a0),
                  GlobalCompact);

DETOUR_TRAMPOLINE(ATOM __stdcall Real_GlobalDeleteAtom(ATOM a0),
                  GlobalDeleteAtom);

DETOUR_TRAMPOLINE(ATOM __stdcall Real_GlobalFindAtomA(LPCSTR a0),
                  GlobalFindAtomA);

DETOUR_TRAMPOLINE(ATOM __stdcall Real_GlobalFindAtomW(LPCWSTR a0),
                  GlobalFindAtomW);

DETOUR_TRAMPOLINE(void __stdcall Real_GlobalFix(HGLOBAL a0),
                  GlobalFix);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GlobalFlags(HGLOBAL a0),
                  GlobalFlags);

DETOUR_TRAMPOLINE(HGLOBAL __stdcall Real_GlobalFree(HGLOBAL a0),
                  GlobalFree);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GlobalGetAtomNameA(ATOM a0,
                                                         LPSTR a1,
                                                         int a2),
                  GlobalGetAtomNameA);

DETOUR_TRAMPOLINE(UINT __stdcall Real_GlobalGetAtomNameW(ATOM a0,
                                                         LPWSTR a1,
                                                         int a2),
                  GlobalGetAtomNameW);

DETOUR_TRAMPOLINE(HGLOBAL __stdcall Real_GlobalHandle(LPCVOID a0),
                  GlobalHandle);

DETOUR_TRAMPOLINE(LPVOID __stdcall Real_GlobalLock(HGLOBAL a0),
                  GlobalLock);

DETOUR_TRAMPOLINE(void __stdcall Real_GlobalMemoryStatus(LPMEMORYSTATUS a0),
                  GlobalMemoryStatus);

DETOUR_TRAMPOLINE(HGLOBAL __stdcall Real_GlobalReAlloc(HGLOBAL a0,
                                                       SIZE_T a1,
                                                       UINT a2),
                  GlobalReAlloc);

DETOUR_TRAMPOLINE(SIZE_T __stdcall Real_GlobalSize(HGLOBAL a0),
                  GlobalSize);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GlobalUnWire(HGLOBAL a0),
                  GlobalUnWire);

DETOUR_TRAMPOLINE(void __stdcall Real_GlobalUnfix(HGLOBAL a0),
                  GlobalUnfix);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GlobalUnlock(HGLOBAL a0),
                  GlobalUnlock);

DETOUR_TRAMPOLINE(LPVOID __stdcall Real_GlobalWire(HGLOBAL a0),
                  GlobalWire);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GrayStringA(HDC a0,
                                                  HBRUSH a1,
                                                  GRAYSTRINGPROC a2,
                                                  LPARAM a3,
                                                  int a4,
                                                  int a5,
                                                  int a6,
                                                  int a7,
                                                  int a8),
                  GrayStringA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_GrayStringW(HDC a0,
                                                  HBRUSH a1,
                                                  GRAYSTRINGPROC a2,
                                                  LPARAM a3,
                                                  int a4,
                                                  int a5,
                                                  int a6,
                                                  int a7,
                                                  int a8),
                  GrayStringW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_HeapLock(HANDLE a0),
                  HeapLock);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_HeapUnlock(HANDLE a0),
                  HeapUnlock);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_HideCaret(HWND a0),
                  HideCaret);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_HiliteMenuItem(HWND a0,
                                                     HMENU a1,
                                                     UINT a2,
                                                     UINT a3),
                  HiliteMenuItem);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_IIDFromString(LPOLESTR a0,
                                                       struct _GUID* a1),
                  IIDFromString);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ImpersonateDdeClientWindow(HWND a0,
                                                                 HWND a1),
                  ImpersonateDdeClientWindow);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_InSendMessage(void),
                  InSendMessage);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_InflateRect(LPRECT a0,
                                                  int a1,
                                                  int a2),
                  InflateRect);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_InitAtomTable(DWORD a0),
                  InitAtomTable);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_InsertMenuA(HMENU a0,
                                                  UINT a1,
                                                  UINT a2,
                                                  UINT_PTR a3,
                                                  LPCSTR a4),
                  InsertMenuA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_InsertMenuItemA(HMENU a0,
                                                      UINT a1,
                                                      BOOL a2,
                                                      struct tagMENUITEMINFOA* a3),
                  InsertMenuItemA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_InsertMenuItemW(HMENU a0,
                                                      UINT a1,
                                                      BOOL a2,
                                                      struct tagMENUITEMINFOW* a3),
                  InsertMenuItemW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_InsertMenuW(HMENU a0,
                                                  UINT a1,
                                                  UINT a2,
                                                  UINT_PTR a3,
                                                  LPCWSTR a4),
                  InsertMenuW);

DETOUR_TRAMPOLINE(int __stdcall Real_IntersectClipRect(HDC a0,
                                                       int a1,
                                                       int a2,
                                                       int a3,
                                                       int a4),
                  IntersectClipRect);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IntersectRect(LPRECT a0,
                                                    RECT* a1,
                                                    RECT* a2),
                  IntersectRect);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_InvalidateRect(HWND a0,
                                                     RECT* a1,
                                                     BOOL a2),
                  InvalidateRect);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_InvalidateRgn(HWND a0,
                                                    HRGN a1,
                                                    BOOL a2),
                  InvalidateRgn);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_InvertRect(HDC a0,
                                                 RECT* a1),
                  InvertRect);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_InvertRgn(HDC a0,
                                                HRGN a1),
                  InvertRgn);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsAccelerator(HACCEL a0,
                                                    int a1,
                                                    LPMSG a2,
                                                    WORD* a3),
                  IsAccelerator);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsBadCodePtr(FARPROC a0),
                  IsBadCodePtr);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsBadHugeReadPtr(void* a0,
                                                       UINT_PTR a1),
                  IsBadHugeReadPtr);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsBadHugeWritePtr(LPVOID a0,
                                                        UINT_PTR a1),
                  IsBadHugeWritePtr);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsBadReadPtr(void* a0,
                                                   UINT_PTR a1),
                  IsBadReadPtr);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsBadStringPtrA(LPCSTR a0,
                                                      UINT_PTR a1),
                  IsBadStringPtrA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsBadStringPtrW(LPCWSTR a0,
                                                      UINT_PTR a1),
                  IsBadStringPtrW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsBadWritePtr(LPVOID a0,
                                                    UINT_PTR a1),
                  IsBadWritePtr);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsCharAlphaA(CHAR a0),
                  IsCharAlphaA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsCharAlphaNumericA(CHAR a0),
                  IsCharAlphaNumericA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsCharAlphaNumericW(WCHAR a0),
                  IsCharAlphaNumericW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsCharAlphaW(WCHAR a0),
                  IsCharAlphaW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsCharLowerA(CHAR a0),
                  IsCharLowerA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsCharLowerW(WCHAR a0),
                  IsCharLowerW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsCharUpperA(CHAR a0),
                  IsCharUpperA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsCharUpperW(WCHAR a0),
                  IsCharUpperW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsChild(HWND a0,
                                              HWND a1),
                  IsChild);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsClipboardFormatAvailable(UINT a0),
                  IsClipboardFormatAvailable);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsDBCSLeadByte(BYTE a0),
                  IsDBCSLeadByte);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsDBCSLeadByteEx(UINT a0,
                                                       BYTE a1),
                  IsDBCSLeadByteEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsDebuggerPresent(void),
                  IsDebuggerPresent);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsDialogMessageA(HWND a0,
                                                       LPMSG a1),
                  IsDialogMessageA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsDialogMessageW(HWND a0,
                                                       LPMSG a1),
                  IsDialogMessageW);

DETOUR_TRAMPOLINE(UINT __stdcall Real_IsDlgButtonChecked(HWND a0,
                                                         int a1),
                  IsDlgButtonChecked);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsIconic(HWND a0),
                  IsIconic);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsMenu(HMENU a0),
                  IsMenu);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsProcessorFeaturePresent(DWORD a0),
                  IsProcessorFeaturePresent);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsRectEmpty(RECT* a0),
                  IsRectEmpty);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsValidCodePage(UINT a0),
                  IsValidCodePage);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsValidLocale(LCID a0,
                                                    DWORD a1),
                  IsValidLocale);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsWindow(HWND a0),
                  IsWindow);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsWindowEnabled(HWND a0),
                  IsWindowEnabled);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsWindowUnicode(HWND a0),
                  IsWindowUnicode);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsWindowVisible(HWND a0),
                  IsWindowVisible);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_IsZoomed(HWND a0),
                  IsZoomed);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_KillTimer(HWND a0,
                                                UINT_PTR a1),
                  KillTimer);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_LPtoDP(HDC a0,
                                             struct tagPOINT* a1,
                                             int a2),
                  LPtoDP);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_LineDDA(int a0,
                                              int a1,
                                              int a2,
                                              int a3,
                                              LINEDDAPROC a4,
                                              LPARAM a5),
                  LineDDA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_LineTo(HDC a0,
                                             int a1,
                                             int a2),
                  LineTo);

DETOUR_TRAMPOLINE(HACCEL __stdcall Real_LoadAcceleratorsA(HINSTANCE a0,
                                                          LPCSTR a1),
                  LoadAcceleratorsA);

DETOUR_TRAMPOLINE(HACCEL __stdcall Real_LoadAcceleratorsW(HINSTANCE a0,
                                                          LPCWSTR a1),
                  LoadAcceleratorsW);

DETOUR_TRAMPOLINE(HBITMAP __stdcall Real_LoadBitmapA(HINSTANCE a0,
                                                     LPCSTR a1),
                  LoadBitmapA);

DETOUR_TRAMPOLINE(HBITMAP __stdcall Real_LoadBitmapW(HINSTANCE a0,
                                                     LPCWSTR a1),
                  LoadBitmapW);

DETOUR_TRAMPOLINE(HCURSOR __stdcall Real_LoadCursorA(HINSTANCE a0,
                                                     LPCSTR a1),
                  LoadCursorA);

DETOUR_TRAMPOLINE(HCURSOR __stdcall Real_LoadCursorFromFileA(LPCSTR a0),
                  LoadCursorFromFileA);

DETOUR_TRAMPOLINE(HCURSOR __stdcall Real_LoadCursorFromFileW(LPCWSTR a0),
                  LoadCursorFromFileW);

DETOUR_TRAMPOLINE(HCURSOR __stdcall Real_LoadCursorW(HINSTANCE a0,
                                                     LPCWSTR a1),
                  LoadCursorW);

DETOUR_TRAMPOLINE(HICON __stdcall Real_LoadIconA(HINSTANCE a0,
                                                 LPCSTR a1),
                  LoadIconA);

DETOUR_TRAMPOLINE(HICON __stdcall Real_LoadIconW(HINSTANCE a0,
                                                 LPCWSTR a1),
                  LoadIconW);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_LoadImageA(HINSTANCE a0,
                                                   LPCSTR a1,
                                                   UINT a2,
                                                   int a3,
                                                   int a4,
                                                   UINT a5),
                  LoadImageA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_LoadImageW(HINSTANCE a0,
                                                   LPCWSTR a1,
                                                   UINT a2,
                                                   int a3,
                                                   int a4,
                                                   UINT a5),
                  LoadImageW);

DETOUR_TRAMPOLINE(HKL __stdcall Real_LoadKeyboardLayoutA(LPCSTR a0,
                                                         UINT a1),
                  LoadKeyboardLayoutA);

DETOUR_TRAMPOLINE(HKL __stdcall Real_LoadKeyboardLayoutW(LPCWSTR a0,
                                                         UINT a1),
                  LoadKeyboardLayoutW);

DETOUR_TRAMPOLINE(HMODULE __stdcall Real_LoadLibraryA(LPCSTR a0),
                  LoadLibraryA);

DETOUR_TRAMPOLINE(HMODULE __stdcall Real_LoadLibraryExA(LPCSTR a0,
                                                        HANDLE a1,
                                                        DWORD a2),
                  LoadLibraryExA);

DETOUR_TRAMPOLINE(HMODULE __stdcall Real_LoadLibraryExW(LPCWSTR a0,
                                                        HANDLE a1,
                                                        DWORD a2),
                  LoadLibraryExW);

DETOUR_TRAMPOLINE(HMODULE __stdcall Real_LoadLibraryW(LPCWSTR a0),
                  LoadLibraryW);

DETOUR_TRAMPOLINE(HMENU __stdcall Real_LoadMenuA(HINSTANCE a0,
                                                 LPCSTR a1),
                  LoadMenuA);

DETOUR_TRAMPOLINE(HMENU __stdcall Real_LoadMenuIndirectA(MENUTEMPLATEA* a0),
                  LoadMenuIndirectA);

DETOUR_TRAMPOLINE(HMENU __stdcall Real_LoadMenuIndirectW(MENUTEMPLATEW* a0),
                  LoadMenuIndirectW);

DETOUR_TRAMPOLINE(HMENU __stdcall Real_LoadMenuW(HINSTANCE a0,
                                                 LPCWSTR a1),
                  LoadMenuW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_LoadModule(LPCSTR a0,
                                                  LPVOID a1),
                  LoadModule);

DETOUR_TRAMPOLINE(HGLOBAL __stdcall Real_LoadResource(HMODULE a0,
                                                      HRSRC a1),
                  LoadResource);

DETOUR_TRAMPOLINE(int __stdcall Real_LoadStringA(HINSTANCE a0,
                                                 UINT a1,
                                                 LPSTR a2,
                                                 int a3),
                  LoadStringA);

DETOUR_TRAMPOLINE(int __stdcall Real_LoadStringW(HINSTANCE a0,
                                                 UINT a1,
                                                 LPWSTR a2,
                                                 int a3),
                  LoadStringW);

DETOUR_TRAMPOLINE(HLOCAL __stdcall Real_LocalAlloc(UINT a0,
                                                   SIZE_T a1),
                  LocalAlloc);

DETOUR_TRAMPOLINE(SIZE_T __stdcall Real_LocalCompact(UINT a0),
                  LocalCompact);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_LocalFileTimeToFileTime(FILETIME* a0,
                                                              LPFILETIME a1),
                  LocalFileTimeToFileTime);

DETOUR_TRAMPOLINE(UINT __stdcall Real_LocalFlags(HLOCAL a0),
                  LocalFlags);

DETOUR_TRAMPOLINE(HLOCAL __stdcall Real_LocalFree(HLOCAL a0),
                  LocalFree);

DETOUR_TRAMPOLINE(HLOCAL __stdcall Real_LocalHandle(LPCVOID a0),
                  LocalHandle);

DETOUR_TRAMPOLINE(LPVOID __stdcall Real_LocalLock(HLOCAL a0),
                  LocalLock);

DETOUR_TRAMPOLINE(HLOCAL __stdcall Real_LocalReAlloc(HLOCAL a0,
                                                     SIZE_T a1,
                                                     UINT a2),
                  LocalReAlloc);

DETOUR_TRAMPOLINE(SIZE_T __stdcall Real_LocalShrink(HLOCAL a0,
                                                    UINT a1),
                  LocalShrink);

DETOUR_TRAMPOLINE(SIZE_T __stdcall Real_LocalSize(HLOCAL a0),
                  LocalSize);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_LocalUnlock(HLOCAL a0),
                  LocalUnlock);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_LockFile(HANDLE a0,
                                               DWORD a1,
                                               DWORD a2,
                                               DWORD a3,
                                               DWORD a4),
                  LockFile);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_LockFileEx(HANDLE a0,
                                                 DWORD a1,
                                                 DWORD a2,
                                                 DWORD a3,
                                                 DWORD a4,
                                                 LPOVERLAPPED a5),
                  LockFileEx);

DETOUR_TRAMPOLINE(LPVOID __stdcall Real_LockResource(HGLOBAL a0),
                  LockResource);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_LockWindowUpdate(HWND a0),
                  LockWindowUpdate);

DETOUR_TRAMPOLINE(int __stdcall Real_LookupIconIdFromDirectory(PBYTE a0,
                                                               BOOL a1),
                  LookupIconIdFromDirectory);

DETOUR_TRAMPOLINE(int __stdcall Real_LookupIconIdFromDirectoryEx(PBYTE a0,
                                                                 BOOL a1,
                                                                 int a2,
                                                                 int a3,
                                                                 UINT a4),
                  LookupIconIdFromDirectoryEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_MapDialogRect(HWND a0,
                                                    LPRECT a1),
                  MapDialogRect);

DETOUR_TRAMPOLINE(LPVOID __stdcall Real_MapViewOfFile(HANDLE a0,
                                                      DWORD a1,
                                                      DWORD a2,
                                                      DWORD a3,
                                                      SIZE_T a4),
                  MapViewOfFile);

DETOUR_TRAMPOLINE(LPVOID __stdcall Real_MapViewOfFileEx(HANDLE a0,
                                                        DWORD a1,
                                                        DWORD a2,
                                                        DWORD a3,
                                                        SIZE_T a4,
                                                        LPVOID a5),
                  MapViewOfFileEx);

DETOUR_TRAMPOLINE(UINT __stdcall Real_MapVirtualKeyA(UINT a0,
                                                     UINT a1),
                  MapVirtualKeyA);

DETOUR_TRAMPOLINE(UINT __stdcall Real_MapVirtualKeyExA(UINT a0,
                                                       UINT a1,
                                                       HKL a2),
                  MapVirtualKeyExA);

DETOUR_TRAMPOLINE(UINT __stdcall Real_MapVirtualKeyExW(UINT a0,
                                                       UINT a1,
                                                       HKL a2),
                  MapVirtualKeyExW);

DETOUR_TRAMPOLINE(UINT __stdcall Real_MapVirtualKeyW(UINT a0,
                                                     UINT a1),
                  MapVirtualKeyW);

DETOUR_TRAMPOLINE(int __stdcall Real_MapWindowPoints(HWND a0,
                                                     HWND a1,
                                                     struct tagPOINT* a2,
                                                     UINT a3),
                  MapWindowPoints);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_MaskBlt(HDC a0,
                                              int a1,
                                              int a2,
                                              int a3,
                                              int a4,
                                              HDC a5,
                                              int a6,
                                              int a7,
                                              HBITMAP a8,
                                              int a9,
                                              int a10,
                                              DWORD a11),
                  MaskBlt);

DETOUR_TRAMPOLINE(int __stdcall Real_MenuItemFromPoint(HWND a0,
                                                       HMENU a1,
                                                       POINT a2),
                  MenuItemFromPoint);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_MessageBeep(UINT a0),
                  MessageBeep);

DETOUR_TRAMPOLINE(int __stdcall Real_MessageBoxA(HWND a0,
                                                 LPCSTR a1,
                                                 LPCSTR a2,
                                                 UINT a3),
                  MessageBoxA);

DETOUR_TRAMPOLINE(int __stdcall Real_MessageBoxExA(HWND a0,
                                                   LPCSTR a1,
                                                   LPCSTR a2,
                                                   UINT a3,
                                                   WORD a4),
                  MessageBoxExA);

DETOUR_TRAMPOLINE(int __stdcall Real_MessageBoxExW(HWND a0,
                                                   LPCWSTR a1,
                                                   LPCWSTR a2,
                                                   UINT a3,
                                                   WORD a4),
                  MessageBoxExW);

DETOUR_TRAMPOLINE(int __stdcall Real_MessageBoxIndirectA(struct tagMSGBOXPARAMSA* a0),
                  MessageBoxIndirectA);

DETOUR_TRAMPOLINE(int __stdcall Real_MessageBoxIndirectW(struct tagMSGBOXPARAMSW* a0),
                  MessageBoxIndirectW);

DETOUR_TRAMPOLINE(int __stdcall Real_MessageBoxW(HWND a0,
                                                 LPCWSTR a1,
                                                 LPCWSTR a2,
                                                 UINT a3),
                  MessageBoxW);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_MkParseDisplayName(struct IBindCtx* a0,
                                                            LPCOLESTR a1,
                                                            ULONG* a2,
                                                            struct IMoniker** a3),
                  MkParseDisplayName);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ModifyMenuA(HMENU a0,
                                                  UINT a1,
                                                  UINT a2,
                                                  UINT_PTR a3,
                                                  LPCSTR a4),
                  ModifyMenuA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ModifyMenuW(HMENU a0,
                                                  UINT a1,
                                                  UINT a2,
                                                  UINT_PTR a3,
                                                  LPCWSTR a4),
                  ModifyMenuW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ModifyWorldTransform(HDC a0,
                                                           XFORM* a1,
                                                           DWORD a2),
                  ModifyWorldTransform);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_MonikerCommonPrefixWith(struct IMoniker* a0,
                                                                 struct IMoniker* a1,
                                                                 struct IMoniker** a2),
                  MonikerCommonPrefixWith);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_MonikerRelativePathTo(struct IMoniker* a0,
                                                               struct IMoniker* a1,
                                                               struct IMoniker** a2,
                                                               BOOL a3),
                  MonikerRelativePathTo);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_MoveFileA(LPCSTR a0,
                                                LPCSTR a1),
                  MoveFileA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_MoveFileExA(LPCSTR a0,
                                                  LPCSTR a1,
                                                  DWORD a2),
                  MoveFileExA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_MoveFileExW(LPCWSTR a0,
                                                  LPCWSTR a1,
                                                  DWORD a2),
                  MoveFileExW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_MoveFileW(LPCWSTR a0,
                                                LPCWSTR a1),
                  MoveFileW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_MoveToEx(HDC a0,
                                               int a1,
                                               int a2,
                                               struct tagPOINT* a3),
                  MoveToEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_MoveWindow(HWND a0,
                                                 int a1,
                                                 int a2,
                                                 int a3,
                                                 int a4,
                                                 BOOL a5),
                  MoveWindow);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_MsgWaitForMultipleObjects(DWORD a0,
                                                                 void** a1,
                                                                 BOOL a2,
                                                                 DWORD a3,
                                                                 DWORD a4),
                  MsgWaitForMultipleObjects);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_MsgWaitForMultipleObjectsEx(DWORD a0,
                                                                   void** a1,
                                                                   DWORD a2,
                                                                   DWORD a3,
                                                                   DWORD a4),
                  MsgWaitForMultipleObjectsEx);

DETOUR_TRAMPOLINE(int __stdcall Real_MulDiv(int a0,
                                            int a1,
                                            int a2),
                  MulDiv);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_OemKeyScan(WORD a0),
                  OemKeyScan);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_OemToCharA(LPCSTR a0,
                                                 LPSTR a1),
                  OemToCharA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_OemToCharBuffA(LPCSTR a0,
                                                     LPSTR a1,
                                                     DWORD a2),
                  OemToCharBuffA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_OemToCharBuffW(LPCSTR a0,
                                                     LPWSTR a1,
                                                     DWORD a2),
                  OemToCharBuffW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_OemToCharW(LPCSTR a0,
                                                 LPWSTR a1),
                  OemToCharW);

DETOUR_TRAMPOLINE(int __stdcall Real_OffsetClipRgn(HDC a0,
                                                   int a1,
                                                   int a2),
                  OffsetClipRgn);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_OffsetRect(LPRECT a0,
                                                 int a1,
                                                 int a2),
                  OffsetRect);

DETOUR_TRAMPOLINE(int __stdcall Real_OffsetRgn(HRGN a0,
                                               int a1,
                                               int a2),
                  OffsetRgn);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_OffsetViewportOrgEx(HDC a0,
                                                          int a1,
                                                          int a2,
                                                          struct tagPOINT* a3),
                  OffsetViewportOrgEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_OffsetWindowOrgEx(HDC a0,
                                                        int a1,
                                                        int a2,
                                                        struct tagPOINT* a3),
                  OffsetWindowOrgEx);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_OleBuildVersion(void),
                  OleBuildVersion);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleConvertIStorageToOLESTREAM(struct IStorage* a0,
                                                                       LPOLESTREAM a1),
                  OleConvertIStorageToOLESTREAM);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleConvertIStorageToOLESTREAMEx(struct IStorage* a0,
                                                                         CLIPFORMAT a1,
                                                                         LONG a2,
                                                                         LONG a3,
                                                                         DWORD a4,
                                                                         LPSTGMEDIUM a5,
                                                                         LPOLESTREAM a6),
                  OleConvertIStorageToOLESTREAMEx);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleConvertOLESTREAMToIStorage(LPOLESTREAM a0,
                                                                       struct IStorage* a1,
                                                                       DVTARGETDEVICE* a2),
                  OleConvertOLESTREAMToIStorage);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleConvertOLESTREAMToIStorageEx(LPOLESTREAM a0,
                                                                         struct IStorage* a1,
                                                                         CLIPFORMAT* a2,
                                                                         LONG* a3,
                                                                         LONG* a4,
                                                                         DWORD* a5,
                                                                         LPSTGMEDIUM a6),
                  OleConvertOLESTREAMToIStorageEx);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleCreate(IID& a0,
                                                   IID& a1,
                                                   DWORD a2,
                                                   LPFORMATETC a3,
                                                   LPOLECLIENTSITE a4,
                                                   struct IStorage* a5,
                                                   LPVOID* a6),
                  OleCreate);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleCreateDefaultHandler(IID& a0,
                                                                 LPUNKNOWN a1,
                                                                 IID& a2,
                                                                 LPVOID* a3),
                  OleCreateDefaultHandler);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleCreateEmbeddingHelper(IID& a0,
                                                                  LPUNKNOWN a1,
                                                                  DWORD a2,
                                                                  LPCLASSFACTORY a3,
                                                                  IID& a4,
                                                                  LPVOID* a5),
                  OleCreateEmbeddingHelper);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleCreateEx(IID& a0,
                                                     IID& a1,
                                                     DWORD a2,
                                                     DWORD a3,
                                                     ULONG a4,
                                                     DWORD* a5,
                                                     LPFORMATETC a6,
                                                     IAdviseSink* a7,
                                                     DWORD* a8,
                                                     LPOLECLIENTSITE a9,
                                                     struct IStorage* a10,
                                                     LPVOID* a11),
                  OleCreateEx);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleCreateFromData(struct IDataObject* a0,
                                                           IID& a1,
                                                           DWORD a2,
                                                           LPFORMATETC a3,
                                                           LPOLECLIENTSITE a4,
                                                           struct IStorage* a5,
                                                           LPVOID* a6),
                  OleCreateFromData);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleCreateFromDataEx(struct IDataObject* a0,
                                                             IID& a1,
                                                             DWORD a2,
                                                             DWORD a3,
                                                             ULONG a4,
                                                             DWORD* a5,
                                                             LPFORMATETC a6,
                                                             IAdviseSink* a7,
                                                             DWORD* a8,
                                                             LPOLECLIENTSITE a9,
                                                             struct IStorage* a10,
                                                             LPVOID* a11),
                  OleCreateFromDataEx);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleCreateFromFile(IID& a0,
                                                           LPCOLESTR a1,
                                                           IID& a2,
                                                           DWORD a3,
                                                           LPFORMATETC a4,
                                                           LPOLECLIENTSITE a5,
                                                           struct IStorage* a6,
                                                           LPVOID* a7),
                  OleCreateFromFile);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleCreateFromFileEx(IID& a0,
                                                             LPCOLESTR a1,
                                                             IID& a2,
                                                             DWORD a3,
                                                             DWORD a4,
                                                             ULONG a5,
                                                             DWORD* a6,
                                                             LPFORMATETC a7,
                                                             IAdviseSink* a8,
                                                             DWORD* a9,
                                                             LPOLECLIENTSITE a10,
                                                             struct IStorage* a11,
                                                             LPVOID* a12),
                  OleCreateFromFileEx);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleCreateLink(struct IMoniker* a0,
                                                       IID& a1,
                                                       DWORD a2,
                                                       LPFORMATETC a3,
                                                       LPOLECLIENTSITE a4,
                                                       struct IStorage* a5,
                                                       LPVOID* a6),
                  OleCreateLink);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleCreateLinkEx(struct IMoniker* a0,
                                                         IID& a1,
                                                         DWORD a2,
                                                         DWORD a3,
                                                         ULONG a4,
                                                         DWORD* a5,
                                                         LPFORMATETC a6,
                                                         IAdviseSink* a7,
                                                         DWORD* a8,
                                                         LPOLECLIENTSITE a9,
                                                         struct IStorage* a10,
                                                         LPVOID* a11),
                  OleCreateLinkEx);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleCreateLinkFromData(struct IDataObject* a0,
                                                               IID& a1,
                                                               DWORD a2,
                                                               LPFORMATETC a3,
                                                               LPOLECLIENTSITE a4,
                                                               struct IStorage* a5,
                                                               LPVOID* a6),
                  OleCreateLinkFromData);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleCreateLinkFromDataEx(struct IDataObject* a0,
                                                                 IID& a1,
                                                                 DWORD a2,
                                                                 DWORD a3,
                                                                 ULONG a4,
                                                                 DWORD* a5,
                                                                 LPFORMATETC a6,
                                                                 IAdviseSink* a7,
                                                                 DWORD* a8,
                                                                 LPOLECLIENTSITE a9,
                                                                 struct IStorage* a10,
                                                                 LPVOID* a11),
                  OleCreateLinkFromDataEx);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleCreateLinkToFile(LPCOLESTR a0,
                                                             IID& a1,
                                                             DWORD a2,
                                                             LPFORMATETC a3,
                                                             LPOLECLIENTSITE a4,
                                                             struct IStorage* a5,
                                                             LPVOID* a6),
                  OleCreateLinkToFile);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleCreateLinkToFileEx(LPCOLESTR a0,
                                                               IID& a1,
                                                               DWORD a2,
                                                               DWORD a3,
                                                               ULONG a4,
                                                               DWORD* a5,
                                                               LPFORMATETC a6,
                                                               IAdviseSink* a7,
                                                               DWORD* a8,
                                                               LPOLECLIENTSITE a9,
                                                               struct IStorage* a10,
                                                               LPVOID* a11),
                  OleCreateLinkToFileEx);

DETOUR_TRAMPOLINE(HOLEMENU __stdcall Real_OleCreateMenuDescriptor(HMENU a0,
                                                                  LPOLEMENUGROUPWIDTHS a1),
                  OleCreateMenuDescriptor);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleCreateStaticFromData(struct IDataObject* a0,
                                                                 IID& a1,
                                                                 DWORD a2,
                                                                 LPFORMATETC a3,
                                                                 LPOLECLIENTSITE a4,
                                                                 struct IStorage* a5,
                                                                 LPVOID* a6),
                  OleCreateStaticFromData);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleDestroyMenuDescriptor(HOLEMENU a0),
                  OleDestroyMenuDescriptor);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleDoAutoConvert(struct IStorage* a0,
                                                          struct _GUID* a1),
                  OleDoAutoConvert);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleDraw(LPUNKNOWN a0,
                                                 DWORD a1,
                                                 HDC a2,
                                                 LPCRECT a3),
                  OleDraw);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_OleDuplicateData(HANDLE a0,
                                                         CLIPFORMAT a1,
                                                         UINT a2),
                  OleDuplicateData);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleFlushClipboard(void),
                  OleFlushClipboard);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleGetAutoConvert(IID& a0,
                                                           struct _GUID* a1),
                  OleGetAutoConvert);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleGetClipboard(struct IDataObject** a0),
                  OleGetClipboard);

DETOUR_TRAMPOLINE(HGLOBAL __stdcall Real_OleGetIconOfClass(IID& a0,
                                                           LPOLESTR a1,
                                                           BOOL a2),
                  OleGetIconOfClass);

DETOUR_TRAMPOLINE(HGLOBAL __stdcall Real_OleGetIconOfFile(LPOLESTR a0,
                                                          BOOL a1),
                  OleGetIconOfFile);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleInitialize(LPVOID a0),
                  OleInitialize);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleIsCurrentClipboard(struct IDataObject* a0),
                  OleIsCurrentClipboard);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_OleIsRunning(struct IOleObject* a0),
                  OleIsRunning);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleLoad(struct IStorage* a0,
                                                 IID& a1,
                                                 LPOLECLIENTSITE a2,
                                                 LPVOID* a3),
                  OleLoad);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleLoadFromStream(LPSTREAM a0,
                                                           IID& a1,
                                                           LPVOID* a2),
                  OleLoadFromStream);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleLockRunning(LPUNKNOWN a0,
                                                        BOOL a1,
                                                        BOOL a2),
                  OleLockRunning);

DETOUR_TRAMPOLINE(HGLOBAL __stdcall Real_OleMetafilePictFromIconAndLabel(HICON a0,
                                                                         LPOLESTR a1,
                                                                         LPOLESTR a2,
                                                                         UINT a3),
                  OleMetafilePictFromIconAndLabel);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleNoteObjectVisible(LPUNKNOWN a0,
                                                              BOOL a1),
                  OleNoteObjectVisible);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleQueryCreateFromData(struct IDataObject* a0),
                  OleQueryCreateFromData);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleQueryLinkFromData(struct IDataObject* a0),
                  OleQueryLinkFromData);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleRegEnumFormatEtc(IID& a0,
                                                             DWORD a1,
                                                             struct IEnumFORMATETC** a2),
                  OleRegEnumFormatEtc);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleRegEnumVerbs(IID& a0,
                                                         struct IEnumOLEVERB** a1),
                  OleRegEnumVerbs);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleRegGetMiscStatus(IID& a0,
                                                             DWORD a1,
                                                             DWORD* a2),
                  OleRegGetMiscStatus);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleRegGetUserType(IID& a0,
                                                           DWORD a1,
                                                           LPOLESTR* a2),
                  OleRegGetUserType);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleRun(LPUNKNOWN a0),
                  OleRun);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleSave(LPPERSISTSTORAGE a0,
                                                 struct IStorage* a1,
                                                 BOOL a2),
                  OleSave);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleSaveToStream(struct IPersistStream* a0,
                                                         LPSTREAM a1),
                  OleSaveToStream);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleSetAutoConvert(IID& a0,
                                                           IID& a1),
                  OleSetAutoConvert);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleSetClipboard(struct IDataObject* a0),
                  OleSetClipboard);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleSetContainedObject(LPUNKNOWN a0,
                                                               BOOL a1),
                  OleSetContainedObject);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleSetMenuDescriptor(HOLEMENU a0,
                                                              HWND a1,
                                                              HWND a2,
                                                              LPOLEINPLACEFRAME a3,
                                                              LPOLEINPLACEACTIVEOBJECT a4),
                  OleSetMenuDescriptor);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_OleTranslateAccelerator(LPOLEINPLACEFRAME a0,
                                                                 LPOLEINPLACEFRAMEINFO a1,
                                                                 LPMSG a2),
                  OleTranslateAccelerator);

DETOUR_TRAMPOLINE(void __stdcall Real_OleUninitialize(void),
                  OleUninitialize);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_OpenClipboard(HWND a0),
                  OpenClipboard);

DETOUR_TRAMPOLINE(HDESK __stdcall Real_OpenDesktopA(LPCSTR a0,
                                                    DWORD a1,
                                                    BOOL a2,
                                                    ACCESS_MASK a3),
                  OpenDesktopA);

DETOUR_TRAMPOLINE(HDESK __stdcall Real_OpenDesktopW(LPCWSTR a0,
                                                    DWORD a1,
                                                    BOOL a2,
                                                    ACCESS_MASK a3),
                  OpenDesktopW);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_OpenEventA(DWORD a0,
                                                   BOOL a1,
                                                   LPCSTR a2),
                  OpenEventA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_OpenEventW(DWORD a0,
                                                   BOOL a1,
                                                   LPCWSTR a2),
                  OpenEventW);

DETOUR_TRAMPOLINE(HFILE __stdcall Real_OpenFile(LPCSTR a0,
                                                struct _OFSTRUCT* a1,
                                                UINT a2),
                  OpenFile);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_OpenFileMappingA(DWORD a0,
                                                         BOOL a1,
                                                         LPCSTR a2),
                  OpenFileMappingA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_OpenFileMappingW(DWORD a0,
                                                         BOOL a1,
                                                         LPCWSTR a2),
                  OpenFileMappingW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_OpenIcon(HWND a0),
                  OpenIcon);

DETOUR_TRAMPOLINE(HDESK __stdcall Real_OpenInputDesktop(DWORD a0,
                                                        BOOL a1,
                                                        ACCESS_MASK a2),
                  OpenInputDesktop);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_OpenMutexA(DWORD a0,
                                                   BOOL a1,
                                                   LPCSTR a2),
                  OpenMutexA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_OpenMutexW(DWORD a0,
                                                   BOOL a1,
                                                   LPCWSTR a2),
                  OpenMutexW);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_OpenProcess(DWORD a0,
                                                    BOOL a1,
                                                    DWORD a2),
                  OpenProcess);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_OpenSemaphoreA(DWORD a0,
                                                       BOOL a1,
                                                       LPCSTR a2),
                  OpenSemaphoreA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_OpenSemaphoreW(DWORD a0,
                                                       BOOL a1,
                                                       LPCWSTR a2),
                  OpenSemaphoreW);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_OpenWaitableTimerA(DWORD a0,
                                                           BOOL a1,
                                                           LPCSTR a2),
                  OpenWaitableTimerA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_OpenWaitableTimerW(DWORD a0,
                                                           BOOL a1,
                                                           LPCWSTR a2),
                  OpenWaitableTimerW);

DETOUR_TRAMPOLINE(HWINSTA __stdcall Real_OpenWindowStationA(LPCSTR a0,
                                                            BOOL a1,
                                                            ACCESS_MASK a2),
                  OpenWindowStationA);

DETOUR_TRAMPOLINE(HWINSTA __stdcall Real_OpenWindowStationW(LPCWSTR a0,
                                                            BOOL a1,
                                                            ACCESS_MASK a2),
                  OpenWindowStationW);

DETOUR_TRAMPOLINE(void __stdcall Real_OutputDebugStringA(LPCSTR a0),
                  OutputDebugStringA);

DETOUR_TRAMPOLINE(void __stdcall Real_OutputDebugStringW(LPCWSTR a0),
                  OutputDebugStringW);

DETOUR_TRAMPOLINE(LPARAM __stdcall Real_PackDDElParam(UINT a0,
                                                      UINT_PTR a1,
                                                      UINT_PTR a2),
                  PackDDElParam);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PaintDesktop(HDC a0),
                  PaintDesktop);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PaintRgn(HDC a0,
                                               HRGN a1),
                  PaintRgn);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PatBlt(HDC a0,
                                             int a1,
                                             int a2,
                                             int a3,
                                             int a4,
                                             DWORD a5),
                  PatBlt);

DETOUR_TRAMPOLINE(HRGN __stdcall Real_PathToRegion(HDC a0),
                  PathToRegion);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PeekConsoleInputA(HANDLE a0,
                                                        PINPUT_RECORD a1,
                                                        DWORD a2,
                                                        LPDWORD a3),
                  PeekConsoleInputA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PeekConsoleInputW(HANDLE a0,
                                                        PINPUT_RECORD a1,
                                                        DWORD a2,
                                                        LPDWORD a3),
                  PeekConsoleInputW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PeekMessageA(LPMSG a0,
                                                   HWND a1,
                                                   UINT a2,
                                                   UINT a3,
                                                   UINT a4),
                  PeekMessageA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PeekMessageW(LPMSG a0,
                                                   HWND a1,
                                                   UINT a2,
                                                   UINT a3,
                                                   UINT a4),
                  PeekMessageW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PeekNamedPipe(HANDLE a0,
                                                    LPVOID a1,
                                                    DWORD a2,
                                                    LPDWORD a3,
                                                    LPDWORD a4,
                                                    LPDWORD a5),
                  PeekNamedPipe);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_Pie(HDC a0,
                                          int a1,
                                          int a2,
                                          int a3,
                                          int a4,
                                          int a5,
                                          int a6,
                                          int a7,
                                          int a8),
                  Pie);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PlayEnhMetaFile(HDC a0,
                                                      HENHMETAFILE a1,
                                                      RECT* a2),
                  PlayEnhMetaFile);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PlayEnhMetaFileRecord(HDC a0,
                                                            LPHANDLETABLE a1,
                                                            ENHMETARECORD* a2,
                                                            UINT a3),
                  PlayEnhMetaFileRecord);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PlayMetaFile(HDC a0,
                                                   HMETAFILE a1),
                  PlayMetaFile);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PlayMetaFileRecord(HDC a0,
                                                         LPHANDLETABLE a1,
                                                         LPMETARECORD a2,
                                                         UINT a3),
                  PlayMetaFileRecord);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PlgBlt(HDC a0,
                                             POINT* a1,
                                             HDC a2,
                                             int a3,
                                             int a4,
                                             int a5,
                                             int a6,
                                             HBITMAP a7,
                                             int a8,
                                             int a9),
                  PlgBlt);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PolyBezier(HDC a0,
                                                 POINT* a1,
                                                 DWORD a2),
                  PolyBezier);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PolyBezierTo(HDC a0,
                                                   POINT* a1,
                                                   DWORD a2),
                  PolyBezierTo);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PolyDraw(HDC a0,
                                               POINT* a1,
                                               BYTE* a2,
                                               int a3),
                  PolyDraw);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PolyPolygon(HDC a0,
                                                  POINT* a1,
                                                  INT* a2,
                                                  int a3),
                  PolyPolygon);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PolyPolyline(HDC a0,
                                                   POINT* a1,
                                                   DWORD* a2,
                                                   DWORD a3),
                  PolyPolyline);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PolyTextOutA(HDC a0,
                                                   struct tagPOLYTEXTA* a1,
                                                   int a2),
                  PolyTextOutA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PolyTextOutW(HDC a0,
                                                   struct tagPOLYTEXTW* a1,
                                                   int a2),
                  PolyTextOutW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_Polygon(HDC a0,
                                              POINT* a1,
                                              int a2),
                  Polygon);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_Polyline(HDC a0,
                                               POINT* a1,
                                               int a2),
                  Polyline);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PolylineTo(HDC a0,
                                                 POINT* a1,
                                                 DWORD a2),
                  PolylineTo);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PostMessageA(HWND a0,
                                                   UINT a1,
                                                   WPARAM a2,
                                                   LPARAM a3),
                  PostMessageA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PostMessageW(HWND a0,
                                                   UINT a1,
                                                   WPARAM a2,
                                                   LPARAM a3),
                  PostMessageW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PostQueuedCompletionStatus(HANDLE a0,
                                                                 DWORD a1,
                                                                 ULONG_PTR a2,
                                                                 LPOVERLAPPED a3),
                  PostQueuedCompletionStatus);

DETOUR_TRAMPOLINE(void __stdcall Real_PostQuitMessage(int a0),
                  PostQuitMessage);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PostThreadMessageA(DWORD a0,
                                                         UINT a1,
                                                         WPARAM a2,
                                                         LPARAM a3),
                  PostThreadMessageA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PostThreadMessageW(DWORD a0,
                                                         UINT a1,
                                                         WPARAM a2,
                                                         LPARAM a3),
                  PostThreadMessageW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_PrepareTape(HANDLE a0,
                                                   DWORD a1,
                                                   BOOL a2),
                  PrepareTape);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_ProgIDFromCLSID(IID& a0,
                                                         LPOLESTR* a1),
                  ProgIDFromCLSID);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_PropStgNameToFmtId(unsigned short* a0,
                                                            FMTID* a1),
                  PropStgNameToFmtId);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_PropVariantClear(PROPVARIANT* a0),
                  PropVariantClear);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_PropVariantCopy(PROPVARIANT* a0,
                                                         PROPVARIANT* a1),
                  PropVariantCopy);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PtInRect(RECT* a0,
                                               POINT a1),
                  PtInRect);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PtInRegion(HRGN a0,
                                                 int a1,
                                                 int a2),
                  PtInRegion);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PtVisible(HDC a0,
                                                int a1,
                                                int a2),
                  PtVisible);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PulseEvent(HANDLE a0),
                  PulseEvent);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_PurgeComm(HANDLE a0,
                                                DWORD a1),
                  PurgeComm);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_QueryDosDeviceA(LPCSTR a0,
                                                       LPSTR a1,
                                                       DWORD a2),
                  QueryDosDeviceA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_QueryDosDeviceW(LPCWSTR a0,
                                                       LPWSTR a1,
                                                       DWORD a2),
                  QueryDosDeviceW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_QueryPerformanceCounter(LARGE_INTEGER* a0),
                  QueryPerformanceCounter);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_QueryPerformanceFrequency(LARGE_INTEGER* a0),
                  QueryPerformanceFrequency);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_QueueUserAPC(PAPCFUNC a0,
                                                    HANDLE a1,
                                                    ULONG_PTR a2),
                  QueueUserAPC);

DETOUR_TRAMPOLINE(void __stdcall Real_RaiseException(DWORD a0,
                                                     DWORD a1,
                                                     DWORD a2,
                                                     ULONG_PTR* a3),
                  RaiseException);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_ReadClassStg(struct IStorage* a0,
                                                      CLSID* a1),
                  ReadClassStg);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_ReadClassStm(LPSTREAM a0,
                                                      CLSID* a1),
                  ReadClassStm);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadConsoleA(HANDLE a0,
                                                   LPVOID a1,
                                                   DWORD a2,
                                                   LPDWORD a3,
                                                   LPVOID a4),
                  ReadConsoleA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadConsoleInputA(HANDLE a0,
                                                        PINPUT_RECORD a1,
                                                        DWORD a2,
                                                        LPDWORD a3),
                  ReadConsoleInputA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadConsoleInputW(HANDLE a0,
                                                        PINPUT_RECORD a1,
                                                        DWORD a2,
                                                        LPDWORD a3),
                  ReadConsoleInputW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadConsoleOutputA(HANDLE a0,
                                                         PCHAR_INFO a1,
                                                         COORD a2,
                                                         COORD a3,
                                                         PSMALL_RECT a4),
                  ReadConsoleOutputA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadConsoleOutputAttribute(HANDLE a0,
                                                                 LPWORD a1,
                                                                 DWORD a2,
                                                                 COORD a3,
                                                                 LPDWORD a4),
                  ReadConsoleOutputAttribute);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadConsoleOutputCharacterA(HANDLE a0,
                                                                  LPSTR a1,
                                                                  DWORD a2,
                                                                  COORD a3,
                                                                  LPDWORD a4),
                  ReadConsoleOutputCharacterA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadConsoleOutputCharacterW(HANDLE a0,
                                                                  LPWSTR a1,
                                                                  DWORD a2,
                                                                  COORD a3,
                                                                  LPDWORD a4),
                  ReadConsoleOutputCharacterW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadConsoleOutputW(HANDLE a0,
                                                         PCHAR_INFO a1,
                                                         COORD a2,
                                                         COORD a3,
                                                         PSMALL_RECT a4),
                  ReadConsoleOutputW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadConsoleW(HANDLE a0,
                                                   LPVOID a1,
                                                   DWORD a2,
                                                   LPDWORD a3,
                                                   LPVOID a4),
                  ReadConsoleW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadDirectoryChangesW(HANDLE a0,
                                                            LPVOID a1,
                                                            DWORD a2,
                                                            BOOL a3,
                                                            DWORD a4,
                                                            LPDWORD a5,
                                                            LPOVERLAPPED a6,
                                                            LPOVERLAPPED_COMPLETION_ROUTINE a7),
                  ReadDirectoryChangesW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadFile(HANDLE a0,
                                               LPVOID a1,
                                               DWORD a2,
                                               LPDWORD a3,
                                               LPOVERLAPPED a4),
                  ReadFile);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadFileEx(HANDLE a0,
                                                 LPVOID a1,
                                                 DWORD a2,
                                                 LPOVERLAPPED a3,
                                                 LPOVERLAPPED_COMPLETION_ROUTINE a4),
                  ReadFileEx);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_ReadFmtUserTypeStg(struct IStorage* a0,
                                                            CLIPFORMAT* a1,
                                                            LPOLESTR* a2),
                  ReadFmtUserTypeStg);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReadProcessMemory(HANDLE a0,
                                                        LPCVOID a1,
                                                        LPVOID a2,
                                                        DWORD a3,
                                                        LPDWORD a4),
                  ReadProcessMemory);

DETOUR_TRAMPOLINE(UINT __stdcall Real_RealizePalette(HDC a0),
                  RealizePalette);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_RectInRegion(HRGN a0,
                                                   RECT* a1),
                  RectInRegion);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_RectVisible(HDC a0,
                                                  RECT* a1),
                  RectVisible);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_Rectangle(HDC a0,
                                                int a1,
                                                int a2,
                                                int a3,
                                                int a4),
                  Rectangle);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_RedrawWindow(HWND a0,
                                                   RECT* a1,
                                                   HRGN a2,
                                                   UINT a3),
                  RedrawWindow);

DETOUR_TRAMPOLINE(ATOM __stdcall Real_RegisterClassA(WNDCLASSA* a0),
                  RegisterClassA);

DETOUR_TRAMPOLINE(ATOM __stdcall Real_RegisterClassExA(struct tagWNDCLASSEXA* a0),
                  RegisterClassExA);

DETOUR_TRAMPOLINE(ATOM __stdcall Real_RegisterClassExW(struct tagWNDCLASSEXW* a0),
                  RegisterClassExW);

DETOUR_TRAMPOLINE(ATOM __stdcall Real_RegisterClassW(WNDCLASSW* a0),
                  RegisterClassW);

DETOUR_TRAMPOLINE(UINT __stdcall Real_RegisterClipboardFormatA(LPCSTR a0),
                  RegisterClipboardFormatA);

DETOUR_TRAMPOLINE(UINT __stdcall Real_RegisterClipboardFormatW(LPCWSTR a0),
                  RegisterClipboardFormatW);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_RegisterDragDrop(HWND a0,
                                                          struct IDropTarget* a1),
                  RegisterDragDrop);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_RegisterHotKey(HWND a0,
                                                     int a1,
                                                     UINT a2,
                                                     UINT a3),
                  RegisterHotKey);

DETOUR_TRAMPOLINE(UINT __stdcall Real_RegisterWindowMessageA(LPCSTR a0),
                  RegisterWindowMessageA);

DETOUR_TRAMPOLINE(UINT __stdcall Real_RegisterWindowMessageW(LPCWSTR a0),
                  RegisterWindowMessageW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReleaseCapture(void),
                  ReleaseCapture);

DETOUR_TRAMPOLINE(int __stdcall Real_ReleaseDC(HWND a0,
                                               HDC a1),
                  ReleaseDC);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReleaseMutex(HANDLE a0),
                  ReleaseMutex);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReleaseSemaphore(HANDLE a0,
                                                       LONG a1,
                                                       LPLONG a2),
                  ReleaseSemaphore);

DETOUR_TRAMPOLINE(void __stdcall Real_ReleaseStgMedium(LPSTGMEDIUM a0),
                  ReleaseStgMedium);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_RemoveDirectoryA(LPCSTR a0),
                  RemoveDirectoryA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_RemoveDirectoryW(LPCWSTR a0),
                  RemoveDirectoryW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_RemoveFontResourceA(LPCSTR a0),
                  RemoveFontResourceA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_RemoveFontResourceW(LPCWSTR a0),
                  RemoveFontResourceW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_RemoveMenu(HMENU a0,
                                                 UINT a1,
                                                 UINT a2),
                  RemoveMenu);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_RemovePropA(HWND a0,
                                                    LPCSTR a1),
                  RemovePropA);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_RemovePropW(HWND a0,
                                                    LPCWSTR a1),
                  RemovePropW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ReplyMessage(LRESULT a0),
                  ReplyMessage);

DETOUR_TRAMPOLINE(HDC __stdcall Real_ResetDCA(HDC a0,
                                              struct _devicemodeA* a1),
                  ResetDCA);

DETOUR_TRAMPOLINE(HDC __stdcall Real_ResetDCW(HDC a0,
                                              struct _devicemodeW* a1),
                  ResetDCW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ResetEvent(HANDLE a0),
                  ResetEvent);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ResizePalette(HPALETTE a0,
                                                    UINT a1),
                  ResizePalette);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_RestoreDC(HDC a0,
                                                int a1),
                  RestoreDC);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_ResumeThread(HANDLE a0),
                  ResumeThread);

DETOUR_TRAMPOLINE(LPARAM __stdcall Real_ReuseDDElParam(LPARAM a0,
                                                       UINT a1,
                                                       UINT a2,
                                                       UINT_PTR a3,
                                                       UINT_PTR a4),
                  ReuseDDElParam);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_RevokeDragDrop(HWND a0),
                  RevokeDragDrop);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_RoundRect(HDC a0,
                                                int a1,
                                                int a2,
                                                int a3,
                                                int a4,
                                                int a5,
                                                int a6),
                  RoundRect);

DETOUR_TRAMPOLINE(int __stdcall Real_SaveDC(HDC a0),
                  SaveDC);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ScaleViewportExtEx(HDC a0,
                                                         int a1,
                                                         int a2,
                                                         int a3,
                                                         int a4,
                                                         struct tagSIZE* a5),
                  ScaleViewportExtEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ScaleWindowExtEx(HDC a0,
                                                       int a1,
                                                       int a2,
                                                       int a3,
                                                       int a4,
                                                       struct tagSIZE* a5),
                  ScaleWindowExtEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ScreenToClient(HWND a0,
                                                     struct tagPOINT* a1),
                  ScreenToClient);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ScrollConsoleScreenBufferA(HANDLE a0,
                                                                 SMALL_RECT* a1,
                                                                 SMALL_RECT* a2,
                                                                 COORD a3,
                                                                 CHAR_INFO* a4),
                  ScrollConsoleScreenBufferA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ScrollConsoleScreenBufferW(HANDLE a0,
                                                                 SMALL_RECT* a1,
                                                                 SMALL_RECT* a2,
                                                                 COORD a3,
                                                                 CHAR_INFO* a4),
                  ScrollConsoleScreenBufferW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ScrollDC(HDC a0,
                                               int a1,
                                               int a2,
                                               RECT* a3,
                                               RECT* a4,
                                               HRGN a5,
                                               LPRECT a6),
                  ScrollDC);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ScrollWindow(HWND a0,
                                                   int a1,
                                                   int a2,
                                                   RECT* a3,
                                                   RECT* a4),
                  ScrollWindow);

DETOUR_TRAMPOLINE(int __stdcall Real_ScrollWindowEx(HWND a0,
                                                    int a1,
                                                    int a2,
                                                    RECT* a3,
                                                    RECT* a4,
                                                    HRGN a5,
                                                    LPRECT a6,
                                                    UINT a7),
                  ScrollWindowEx);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_SearchPathA(LPCSTR a0,
                                                   LPCSTR a1,
                                                   LPCSTR a2,
                                                   DWORD a3,
                                                   LPSTR a4,
                                                   LPSTR* a5),
                  SearchPathA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_SearchPathW(LPCWSTR a0,
                                                   LPCWSTR a1,
                                                   LPCWSTR a2,
                                                   DWORD a3,
                                                   LPWSTR a4,
                                                   LPWSTR* a5),
                  SearchPathW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SelectClipPath(HDC a0,
                                                     int a1),
                  SelectClipPath);

DETOUR_TRAMPOLINE(int __stdcall Real_SelectClipRgn(HDC a0,
                                                   HRGN a1),
                  SelectClipRgn);

DETOUR_TRAMPOLINE(HGDIOBJ __stdcall Real_SelectObject(HDC a0,
                                                      HGDIOBJ a1),
                  SelectObject);

DETOUR_TRAMPOLINE(HPALETTE __stdcall Real_SelectPalette(HDC a0,
                                                        HPALETTE a1,
                                                        BOOL a2),
                  SelectPalette);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_SendDlgItemMessageA(HWND a0,
                                                             int a1,
                                                             UINT a2,
                                                             WPARAM a3,
                                                             LPARAM a4),
                  SendDlgItemMessageA);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_SendDlgItemMessageW(HWND a0,
                                                             int a1,
                                                             UINT a2,
                                                             WPARAM a3,
                                                             LPARAM a4),
                  SendDlgItemMessageW);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_SendMessageA(HWND a0,
                                                      UINT a1,
                                                      WPARAM a2,
                                                      LPARAM a3),
                  SendMessageA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SendMessageCallbackA(HWND a0,
                                                           UINT a1,
                                                           WPARAM a2,
                                                           LPARAM a3,
                                                           SENDASYNCPROC a4,
                                                           ULONG_PTR a5),
                  SendMessageCallbackA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SendMessageCallbackW(HWND a0,
                                                           UINT a1,
                                                           WPARAM a2,
                                                           LPARAM a3,
                                                           SENDASYNCPROC a4,
                                                           ULONG_PTR a5),
                  SendMessageCallbackW);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_SendMessageTimeoutA(HWND a0,
                                                             UINT a1,
                                                             WPARAM a2,
                                                             LPARAM a3,
                                                             UINT a4,
                                                             UINT a5,
                                                             PULONG_PTR a6),
                  SendMessageTimeoutA);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_SendMessageTimeoutW(HWND a0,
                                                             UINT a1,
                                                             WPARAM a2,
                                                             LPARAM a3,
                                                             UINT a4,
                                                             UINT a5,
                                                             PULONG_PTR a6),
                  SendMessageTimeoutW);

DETOUR_TRAMPOLINE(LRESULT __stdcall Real_SendMessageW(HWND a0,
                                                      UINT a1,
                                                      WPARAM a2,
                                                      LPARAM a3),
                  SendMessageW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SendNotifyMessageA(HWND a0,
                                                         UINT a1,
                                                         WPARAM a2,
                                                         LPARAM a3),
                  SendNotifyMessageA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SendNotifyMessageW(HWND a0,
                                                         UINT a1,
                                                         WPARAM a2,
                                                         LPARAM a3),
                  SendNotifyMessageW);

DETOUR_TRAMPOLINE(int __stdcall Real_SetAbortProc(HDC a0,
                                                  ABORTPROC a1),
                  SetAbortProc);

DETOUR_TRAMPOLINE(HWND __stdcall Real_SetActiveWindow(HWND a0),
                  SetActiveWindow);

DETOUR_TRAMPOLINE(int __stdcall Real_SetArcDirection(HDC a0,
                                                     int a1),
                  SetArcDirection);

DETOUR_TRAMPOLINE(LONG __stdcall Real_SetBitmapBits(HBITMAP a0,
                                                    DWORD a1,
                                                    void* a2),
                  SetBitmapBits);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetBitmapDimensionEx(HBITMAP a0,
                                                           int a1,
                                                           int a2,
                                                           struct tagSIZE* a3),
                  SetBitmapDimensionEx);

DETOUR_TRAMPOLINE(COLORREF __stdcall Real_SetBkColor(HDC a0,
                                                     COLORREF a1),
                  SetBkColor);

DETOUR_TRAMPOLINE(int __stdcall Real_SetBkMode(HDC a0,
                                               int a1),
                  SetBkMode);

DETOUR_TRAMPOLINE(UINT __stdcall Real_SetBoundsRect(HDC a0,
                                                    RECT* a1,
                                                    UINT a2),
                  SetBoundsRect);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetBrushOrgEx(HDC a0,
                                                    int a1,
                                                    int a2,
                                                    struct tagPOINT* a3),
                  SetBrushOrgEx);

DETOUR_TRAMPOLINE(HWND __stdcall Real_SetCapture(HWND a0),
                  SetCapture);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetCaretBlinkTime(UINT a0),
                  SetCaretBlinkTime);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetCaretPos(int a0,
                                                  int a1),
                  SetCaretPos);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_SetClassLongA(HWND a0,
                                                     int a1,
                                                     LONG a2),
                  SetClassLongA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_SetClassLongW(HWND a0,
                                                     int a1,
                                                     LONG a2),
                  SetClassLongW);

DETOUR_TRAMPOLINE(WORD __stdcall Real_SetClassWord(HWND a0,
                                                   int a1,
                                                   WORD a2),
                  SetClassWord);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_SetClipboardData(UINT a0,
                                                         HANDLE a1),
                  SetClipboardData);

DETOUR_TRAMPOLINE(HWND __stdcall Real_SetClipboardViewer(HWND a0),
                  SetClipboardViewer);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetColorAdjustment(HDC a0,
                                                         COLORADJUSTMENT* a1),
                  SetColorAdjustment);

DETOUR_TRAMPOLINE(HCOLORSPACE __stdcall Real_SetColorSpace(HDC a0,
                                                           HCOLORSPACE a1),
                  SetColorSpace);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetCommBreak(HANDLE a0),
                  SetCommBreak);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetCommConfig(HANDLE a0,
                                                    LPCOMMCONFIG a1,
                                                    DWORD a2),
                  SetCommConfig);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetCommMask(HANDLE a0,
                                                  DWORD a1),
                  SetCommMask);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetCommState(HANDLE a0,
                                                   struct _DCB* a1),
                  SetCommState);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetCommTimeouts(HANDLE a0,
                                                      struct _COMMTIMEOUTS* a1),
                  SetCommTimeouts);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetComputerNameA(LPCSTR a0),
                  SetComputerNameA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetComputerNameW(LPCWSTR a0),
                  SetComputerNameW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetConsoleActiveScreenBuffer(HANDLE a0),
                  SetConsoleActiveScreenBuffer);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetConsoleCP(UINT a0),
                  SetConsoleCP);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetConsoleCtrlHandler(PHANDLER_ROUTINE a0,
                                                            BOOL a1),
                  SetConsoleCtrlHandler);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetConsoleCursorInfo(HANDLE a0,
                                                           CONSOLE_CURSOR_INFO* a1),
                  SetConsoleCursorInfo);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetConsoleCursorPosition(HANDLE a0,
                                                               COORD a1),
                  SetConsoleCursorPosition);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetConsoleMode(HANDLE a0,
                                                     DWORD a1),
                  SetConsoleMode);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetConsoleOutputCP(UINT a0),
                  SetConsoleOutputCP);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetConsoleScreenBufferSize(HANDLE a0,
                                                                 COORD a1),
                  SetConsoleScreenBufferSize);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetConsoleTextAttribute(HANDLE a0,
                                                              WORD a1),
                  SetConsoleTextAttribute);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetConsoleTitleA(LPCSTR a0),
                  SetConsoleTitleA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetConsoleTitleW(LPCWSTR a0),
                  SetConsoleTitleW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetConsoleWindowInfo(HANDLE a0,
                                                           BOOL a1,
                                                           SMALL_RECT* a2),
                  SetConsoleWindowInfo);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_SetConvertStg(struct IStorage* a0,
                                                       BOOL a1),
                  SetConvertStg);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetCurrentDirectoryA(LPCSTR a0),
                  SetCurrentDirectoryA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetCurrentDirectoryW(LPCWSTR a0),
                  SetCurrentDirectoryW);

DETOUR_TRAMPOLINE(HCURSOR __stdcall Real_SetCursor(HCURSOR a0),
                  SetCursor);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetCursorPos(int a0,
                                                   int a1),
                  SetCursorPos);

DETOUR_TRAMPOLINE(UINT __stdcall Real_SetDIBColorTable(HDC a0,
                                                       UINT a1,
                                                       UINT a2,
                                                       RGBQUAD* a3),
                  SetDIBColorTable);

DETOUR_TRAMPOLINE(int __stdcall Real_SetDIBits(HDC a0,
                                               HBITMAP a1,
                                               UINT a2,
                                               UINT a3,
                                               void* a4,
                                               struct tagBITMAPINFO* a5,
                                               UINT a6),
                  SetDIBits);

DETOUR_TRAMPOLINE(int __stdcall Real_SetDIBitsToDevice(HDC a0,
                                                       int a1,
                                                       int a2,
                                                       DWORD a3,
                                                       DWORD a4,
                                                       int a5,
                                                       int a6,
                                                       UINT a7,
                                                       UINT a8,
                                                       void* a9,
                                                       struct tagBITMAPINFO* a10,
                                                       UINT a11),
                  SetDIBitsToDevice);

DETOUR_TRAMPOLINE(void __stdcall Real_SetDebugErrorLevel(DWORD a0),
                  SetDebugErrorLevel);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetDefaultCommConfigA(LPCSTR a0,
                                                            LPCOMMCONFIG a1,
                                                            DWORD a2),
                  SetDefaultCommConfigA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetDefaultCommConfigW(LPCWSTR a0,
                                                            LPCOMMCONFIG a1,
                                                            DWORD a2),
                  SetDefaultCommConfigW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetDeviceGammaRamp(HDC a0,
                                                         LPVOID a1),
                  SetDeviceGammaRamp);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetDlgItemInt(HWND a0,
                                                    int a1,
                                                    UINT a2,
                                                    BOOL a3),
                  SetDlgItemInt);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetDlgItemTextA(HWND a0,
                                                      int a1,
                                                      LPCSTR a2),
                  SetDlgItemTextA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetDlgItemTextW(HWND a0,
                                                      int a1,
                                                      LPCWSTR a2),
                  SetDlgItemTextW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetDoubleClickTime(UINT a0),
                  SetDoubleClickTime);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetEndOfFile(HANDLE a0),
                  SetEndOfFile);

DETOUR_TRAMPOLINE(HENHMETAFILE __stdcall Real_SetEnhMetaFileBits(UINT a0,
                                                                 BYTE* a1),
                  SetEnhMetaFileBits);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetEnvironmentVariableA(LPCSTR a0,
                                                              LPCSTR a1),
                  SetEnvironmentVariableA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetEnvironmentVariableW(LPCWSTR a0,
                                                              LPCWSTR a1),
                  SetEnvironmentVariableW);

DETOUR_TRAMPOLINE(UINT __stdcall Real_SetErrorMode(UINT a0),
                  SetErrorMode);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetEvent(HANDLE a0),
                  SetEvent);

DETOUR_TRAMPOLINE(void __stdcall Real_SetFileApisToANSI(void),
                  SetFileApisToANSI);

DETOUR_TRAMPOLINE(void __stdcall Real_SetFileApisToOEM(void),
                  SetFileApisToOEM);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetFileAttributesA(LPCSTR a0,
                                                         DWORD a1),
                  SetFileAttributesA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetFileAttributesW(LPCWSTR a0,
                                                         DWORD a1),
                  SetFileAttributesW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_SetFilePointer(HANDLE a0,
                                                      LONG a1,
                                                      PLONG a2,
                                                      DWORD a3),
                  SetFilePointer);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetFileTime(HANDLE a0,
                                                  FILETIME* a1,
                                                  FILETIME* a2,
                                                  FILETIME* a3),
                  SetFileTime);

DETOUR_TRAMPOLINE(HWND __stdcall Real_SetFocus(HWND a0),
                  SetFocus);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetForegroundWindow(HWND a0),
                  SetForegroundWindow);

DETOUR_TRAMPOLINE(int __stdcall Real_SetGraphicsMode(HDC a0,
                                                     int a1),
                  SetGraphicsMode);

DETOUR_TRAMPOLINE(UINT __stdcall Real_SetHandleCount(UINT a0),
                  SetHandleCount);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetHandleInformation(HANDLE a0,
                                                           DWORD a1,
                                                           DWORD a2),
                  SetHandleInformation);

DETOUR_TRAMPOLINE(int __stdcall Real_SetICMMode(HDC a0,
                                                int a1),
                  SetICMMode);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetICMProfileA(HDC a0,
                                                     LPSTR a1),
                  SetICMProfileA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetICMProfileW(HDC a0,
                                                     LPWSTR a1),
                  SetICMProfileW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetKeyboardState(LPBYTE a0),
                  SetKeyboardState);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetLocalTime(SYSTEMTIME* a0),
                  SetLocalTime);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetLocaleInfoA(LCID a0,
                                                     LCTYPE a1,
                                                     LPCSTR a2),
                  SetLocaleInfoA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetLocaleInfoW(LCID a0,
                                                     LCTYPE a1,
                                                     LPCWSTR a2),
                  SetLocaleInfoW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetMailslotInfo(HANDLE a0,
                                                      DWORD a1),
                  SetMailslotInfo);

DETOUR_TRAMPOLINE(int __stdcall Real_SetMapMode(HDC a0,
                                                int a1),
                  SetMapMode);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_SetMapperFlags(HDC a0,
                                                      DWORD a1),
                  SetMapperFlags);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetMenu(HWND a0,
                                              HMENU a1),
                  SetMenu);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetMenuContextHelpId(HMENU a0,
                                                           DWORD a1),
                  SetMenuContextHelpId);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetMenuDefaultItem(HMENU a0,
                                                         UINT a1,
                                                         UINT a2),
                  SetMenuDefaultItem);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetMenuItemBitmaps(HMENU a0,
                                                         UINT a1,
                                                         UINT a2,
                                                         HBITMAP a3,
                                                         HBITMAP a4),
                  SetMenuItemBitmaps);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetMenuItemInfoA(HMENU a0,
                                                       UINT a1,
                                                       BOOL a2,
                                                       struct tagMENUITEMINFOA* a3),
                  SetMenuItemInfoA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetMenuItemInfoW(HMENU a0,
                                                       UINT a1,
                                                       BOOL a2,
                                                       struct tagMENUITEMINFOW* a3),
                  SetMenuItemInfoW);

DETOUR_TRAMPOLINE(LPARAM __stdcall Real_SetMessageExtraInfo(LPARAM a0),
                  SetMessageExtraInfo);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetMessageQueue(int a0),
                  SetMessageQueue);

DETOUR_TRAMPOLINE(HMETAFILE __stdcall Real_SetMetaFileBitsEx(UINT a0,
                                                             BYTE* a1),
                  SetMetaFileBitsEx);

DETOUR_TRAMPOLINE(int __stdcall Real_SetMetaRgn(HDC a0),
                  SetMetaRgn);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetMiterLimit(HDC a0,
                                                    FLOAT a1,
                                                    PFLOAT a2),
                  SetMiterLimit);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetNamedPipeHandleState(HANDLE a0,
                                                              LPDWORD a1,
                                                              LPDWORD a2,
                                                              LPDWORD a3),
                  SetNamedPipeHandleState);

DETOUR_TRAMPOLINE(UINT __stdcall Real_SetPaletteEntries(HPALETTE a0,
                                                        UINT a1,
                                                        UINT a2,
                                                        PALETTEENTRY* a3),
                  SetPaletteEntries);

DETOUR_TRAMPOLINE(HWND __stdcall Real_SetParent(HWND a0,
                                                HWND a1),
                  SetParent);

DETOUR_TRAMPOLINE(COLORREF __stdcall Real_SetPixel(HDC a0,
                                                   int a1,
                                                   int a2,
                                                   COLORREF a3),
                  SetPixel);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetPixelFormat(HDC a0,
                                                     int a1,
                                                     PIXELFORMATDESCRIPTOR* a2),
                  SetPixelFormat);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetPixelV(HDC a0,
                                                int a1,
                                                int a2,
                                                COLORREF a3),
                  SetPixelV);

DETOUR_TRAMPOLINE(int __stdcall Real_SetPolyFillMode(HDC a0,
                                                     int a1),
                  SetPolyFillMode);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetPriorityClass(HANDLE a0,
                                                       DWORD a1),
                  SetPriorityClass);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetProcessAffinityMask(HANDLE a0,
                                                             DWORD a1),
                  SetProcessAffinityMask);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetProcessPriorityBoost(HANDLE a0,
                                                              BOOL a1),
                  SetProcessPriorityBoost);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetProcessShutdownParameters(DWORD a0,
                                                                   DWORD a1),
                  SetProcessShutdownParameters);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetProcessWindowStation(HWINSTA a0),
                  SetProcessWindowStation);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetProcessWorkingSetSize(HANDLE a0,
                                                               SIZE_T a1,
                                                               SIZE_T a2),
                  SetProcessWorkingSetSize);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetPropA(HWND a0,
                                               LPCSTR a1,
                                               HANDLE a2),
                  SetPropA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetPropW(HWND a0,
                                               LPCWSTR a1,
                                               HANDLE a2),
                  SetPropW);

DETOUR_TRAMPOLINE(int __stdcall Real_SetROP2(HDC a0,
                                             int a1),
                  SetROP2);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetRect(LPRECT a0,
                                              int a1,
                                              int a2,
                                              int a3,
                                              int a4),
                  SetRect);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetRectEmpty(LPRECT a0),
                  SetRectEmpty);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetRectRgn(HRGN a0,
                                                 int a1,
                                                 int a2,
                                                 int a3,
                                                 int a4),
                  SetRectRgn);

DETOUR_TRAMPOLINE(int __stdcall Real_SetScrollInfo(HWND a0,
                                                   int a1,
                                                   LPCSCROLLINFO a2,
                                                   BOOL a3),
                  SetScrollInfo);

DETOUR_TRAMPOLINE(int __stdcall Real_SetScrollPos(HWND a0,
                                                  int a1,
                                                  int a2,
                                                  BOOL a3),
                  SetScrollPos);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetScrollRange(HWND a0,
                                                     int a1,
                                                     int a2,
                                                     int a3,
                                                     BOOL a4),
                  SetScrollRange);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetStdHandle(DWORD a0,
                                                   HANDLE a1),
                  SetStdHandle);

DETOUR_TRAMPOLINE(int __stdcall Real_SetStretchBltMode(HDC a0,
                                                       int a1),
                  SetStretchBltMode);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetSysColors(int a0,
                                                   INT* a1,
                                                   COLORREF* a2),
                  SetSysColors);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetSystemCursor(HCURSOR a0,
                                                      DWORD a1),
                  SetSystemCursor);

DETOUR_TRAMPOLINE(UINT __stdcall Real_SetSystemPaletteUse(HDC a0,
                                                          UINT a1),
                  SetSystemPaletteUse);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetSystemPowerState(BOOL a0,
                                                          BOOL a1),
                  SetSystemPowerState);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetSystemTime(SYSTEMTIME* a0),
                  SetSystemTime);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetSystemTimeAdjustment(DWORD a0,
                                                              BOOL a1),
                  SetSystemTimeAdjustment);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_SetTapeParameters(HANDLE a0,
                                                         DWORD a1,
                                                         LPVOID a2),
                  SetTapeParameters);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_SetTapePosition(HANDLE a0,
                                                       DWORD a1,
                                                       DWORD a2,
                                                       DWORD a3,
                                                       DWORD a4,
                                                       BOOL a5),
                  SetTapePosition);

DETOUR_TRAMPOLINE(UINT __stdcall Real_SetTextAlign(HDC a0,
                                                   UINT a1),
                  SetTextAlign);

DETOUR_TRAMPOLINE(int __stdcall Real_SetTextCharacterExtra(HDC a0,
                                                           int a1),
                  SetTextCharacterExtra);

DETOUR_TRAMPOLINE(COLORREF __stdcall Real_SetTextColor(HDC a0,
                                                       COLORREF a1),
                  SetTextColor);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetTextJustification(HDC a0,
                                                           int a1,
                                                           int a2),
                  SetTextJustification);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_SetThreadAffinityMask(HANDLE a0,
                                                             DWORD a1),
                  SetThreadAffinityMask);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetThreadContext(HANDLE a0,
                                                       CONTEXT* a1),
                  SetThreadContext);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetThreadDesktop(HDESK a0),
                  SetThreadDesktop);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_SetThreadIdealProcessor(HANDLE a0,
                                                               DWORD a1),
                  SetThreadIdealProcessor);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetThreadLocale(LCID a0),
                  SetThreadLocale);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetThreadPriority(HANDLE a0,
                                                        int a1),
                  SetThreadPriority);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetThreadPriorityBoost(HANDLE a0,
                                                             BOOL a1),
                  SetThreadPriorityBoost);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetTimeZoneInformation(TIME_ZONE_INFORMATION* a0),
                  SetTimeZoneInformation);

DETOUR_TRAMPOLINE(UINT_PTR __stdcall Real_SetTimer(HWND a0,
                                                   UINT_PTR a1,
                                                   UINT a2,
                                                   TIMERPROC a3),
                  SetTimer);

DETOUR_TRAMPOLINE(LPTOP_LEVEL_EXCEPTION_FILTER __stdcall Real_SetUnhandledExceptionFilter(LPTOP_LEVEL_EXCEPTION_FILTER a0),
                  SetUnhandledExceptionFilter);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetUserObjectInformationA(HANDLE a0,
                                                                int a1,
                                                                PVOID a2,
                                                                DWORD a3),
                  SetUserObjectInformationA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetUserObjectInformationW(HANDLE a0,
                                                                int a1,
                                                                PVOID a2,
                                                                DWORD a3),
                  SetUserObjectInformationW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetUserObjectSecurity(HANDLE a0,
                                                            PSECURITY_INFORMATION a1,
                                                            PSECURITY_DESCRIPTOR a2),
                  SetUserObjectSecurity);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetViewportExtEx(HDC a0,
                                                       int a1,
                                                       int a2,
                                                       struct tagSIZE* a3),
                  SetViewportExtEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetViewportOrgEx(HDC a0,
                                                       int a1,
                                                       int a2,
                                                       struct tagPOINT* a3),
                  SetViewportOrgEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetVolumeLabelA(LPCSTR a0,
                                                      LPCSTR a1),
                  SetVolumeLabelA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetVolumeLabelW(LPCWSTR a0,
                                                      LPCWSTR a1),
                  SetVolumeLabelW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetWaitableTimer(HANDLE a0,
                                                       LARGE_INTEGER* a1,
                                                       LONG a2,
                                                       PTIMERAPCROUTINE a3,
                                                       LPVOID a4,
                                                       BOOL a5),
                  SetWaitableTimer);

DETOUR_TRAMPOLINE(HENHMETAFILE __stdcall Real_SetWinMetaFileBits(UINT a0,
                                                                 BYTE* a1,
                                                                 HDC a2,
                                                                 struct tagMETAFILEPICT* a3),
                  SetWinMetaFileBits);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetWindowContextHelpId(HWND a0,
                                                             DWORD a1),
                  SetWindowContextHelpId);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetWindowExtEx(HDC a0,
                                                     int a1,
                                                     int a2,
                                                     struct tagSIZE* a3),
                  SetWindowExtEx);

DETOUR_TRAMPOLINE(LONG __stdcall Real_SetWindowLongA(HWND a0,
                                                     int a1,
                                                     LONG a2),
                  SetWindowLongA);

DETOUR_TRAMPOLINE(LONG __stdcall Real_SetWindowLongW(HWND a0,
                                                     int a1,
                                                     LONG a2),
                  SetWindowLongW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetWindowOrgEx(HDC a0,
                                                     int a1,
                                                     int a2,
                                                     struct tagPOINT* a3),
                  SetWindowOrgEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetWindowPlacement(HWND a0,
                                                         struct tagWINDOWPLACEMENT* a1),
                  SetWindowPlacement);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetWindowPos(HWND a0,
                                                   HWND a1,
                                                   int a2,
                                                   int a3,
                                                   int a4,
                                                   int a5,
                                                   UINT a6),
                  SetWindowPos);

DETOUR_TRAMPOLINE(int __stdcall Real_SetWindowRgn(HWND a0,
                                                  HRGN a1,
                                                  BOOL a2),
                  SetWindowRgn);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetWindowTextA(HWND a0,
                                                     LPCSTR a1),
                  SetWindowTextA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetWindowTextW(HWND a0,
                                                     LPCWSTR a1),
                  SetWindowTextW);

DETOUR_TRAMPOLINE(WORD __stdcall Real_SetWindowWord(HWND a0,
                                                    int a1,
                                                    WORD a2),
                  SetWindowWord);

DETOUR_TRAMPOLINE(HHOOK __stdcall Real_SetWindowsHookA(int a0,
                                                       HOOKPROC a1),
                  SetWindowsHookA);

DETOUR_TRAMPOLINE(HHOOK __stdcall Real_SetWindowsHookExA(int a0,
                                                         HOOKPROC a1,
                                                         HINSTANCE a2,
                                                         DWORD a3),
                  SetWindowsHookExA);

DETOUR_TRAMPOLINE(HHOOK __stdcall Real_SetWindowsHookExW(int a0,
                                                         HOOKPROC a1,
                                                         HINSTANCE a2,
                                                         DWORD a3),
                  SetWindowsHookExW);

DETOUR_TRAMPOLINE(HHOOK __stdcall Real_SetWindowsHookW(int a0,
                                                       HOOKPROC a1),
                  SetWindowsHookW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetWorldTransform(HDC a0,
                                                        XFORM* a1),
                  SetWorldTransform);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SetupComm(HANDLE a0,
                                                DWORD a1,
                                                DWORD a2),
                  SetupComm);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ShowCaret(HWND a0),
                  ShowCaret);

DETOUR_TRAMPOLINE(int __stdcall Real_ShowCursor(BOOL a0),
                  ShowCursor);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ShowOwnedPopups(HWND a0,
                                                      BOOL a1),
                  ShowOwnedPopups);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ShowScrollBar(HWND a0,
                                                    int a1,
                                                    BOOL a2),
                  ShowScrollBar);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ShowWindow(HWND a0,
                                                 int a1),
                  ShowWindow);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ShowWindowAsync(HWND a0,
                                                      int a1),
                  ShowWindowAsync);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_SignalObjectAndWait(HANDLE a0,
                                                           HANDLE a1,
                                                           DWORD a2,
                                                           BOOL a3),
                  SignalObjectAndWait);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_SizeofResource(HMODULE a0,
                                                      HRSRC a1),
                  SizeofResource);

DETOUR_TRAMPOLINE(void __stdcall Real_Sleep(DWORD a0),
                  Sleep);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_SleepEx(DWORD a0,
                                               BOOL a1),
                  SleepEx);

DETOUR_TRAMPOLINE(int __stdcall Real_StartDocA(HDC a0,
                                               DOCINFOA* a1),
                  StartDocA);

DETOUR_TRAMPOLINE(int __stdcall Real_StartDocW(HDC a0,
                                               DOCINFOW* a1),
                  StartDocW);

DETOUR_TRAMPOLINE(int __stdcall Real_StartPage(HDC a0),
                  StartPage);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_StgCreateDocfile(OLECHAR* a0,
                                                          DWORD a1,
                                                          DWORD a2,
                                                          IStorage** a3),
                  StgCreateDocfile);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_StgCreateDocfileOnILockBytes(ILockBytes* a0,
                                                                      DWORD a1,
                                                                      DWORD a2,
                                                                      IStorage** a3),
                  StgCreateDocfileOnILockBytes);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_StgCreatePropSetStg(IStorage* a0,
                                                             DWORD a1,
                                                             IPropertySetStorage** a2),
                  StgCreatePropSetStg);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_StgCreatePropStg(IUnknown* a0,
                                                          IID& a1,
                                                          CLSID* a2,
                                                          DWORD a3,
                                                          DWORD a4,
                                                          IPropertyStorage** a5),
                  StgCreatePropStg);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_StgCreateStorageEx(WCHAR* a0,
                                                            DWORD a1,
                                                            DWORD a2,
                                                            DWORD a3,
                                                            STGOPTIONS* a4,
                                                            void* a5,
                                                            IID& a6,
                                                            void** a7),
                  StgCreateStorageEx);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_StgGetIFillLockBytesOnFile(OLECHAR* a0,
                                                                    IFillLockBytes** a1),
                  StgGetIFillLockBytesOnFile);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_StgGetIFillLockBytesOnILockBytes(ILockBytes* a0,
                                                                          IFillLockBytes** a1),
                  StgGetIFillLockBytesOnILockBytes);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_StgIsStorageFile(OLECHAR* a0),
                  StgIsStorageFile);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_StgIsStorageILockBytes(ILockBytes* a0),
                  StgIsStorageILockBytes);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_StgOpenAsyncDocfileOnIFillLockBytes(IFillLockBytes* a0,
                                                                             DWORD a1,
                                                                             DWORD a2,
                                                                             IStorage** a3),
                  StgOpenAsyncDocfileOnIFillLockBytes);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_StgOpenPropStg(IUnknown* a0,
                                                        IID& a1,
                                                        DWORD a2,
                                                        DWORD a3,
                                                        IPropertyStorage** a4),
                  StgOpenPropStg);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_StgOpenStorage(OLECHAR* a0,
                                                        IStorage* a1,
                                                        DWORD a2,
                                                        SNB a3,
                                                        DWORD a4,
                                                        IStorage** a5),
                  StgOpenStorage);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_StgOpenStorageEx(WCHAR* a0,
                                                          DWORD a1,
                                                          DWORD a2,
                                                          DWORD a3,
                                                          STGOPTIONS* a4,
                                                          void* a5,
                                                          IID& a6,
                                                          void** a7),
                  StgOpenStorageEx);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_StgOpenStorageOnILockBytes(ILockBytes* a0,
                                                                    IStorage* a1,
                                                                    DWORD a2,
                                                                    SNB a3,
                                                                    DWORD a4,
                                                                    IStorage** a5),
                  StgOpenStorageOnILockBytes);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_StgSetTimes(OLECHAR* a0,
                                                     FILETIME* a1,
                                                     FILETIME* a2,
                                                     FILETIME* a3),
                  StgSetTimes);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_StretchBlt(HDC a0,
                                                 int a1,
                                                 int a2,
                                                 int a3,
                                                 int a4,
                                                 HDC a5,
                                                 int a6,
                                                 int a7,
                                                 int a8,
                                                 int a9,
                                                 DWORD a10),
                  StretchBlt);

DETOUR_TRAMPOLINE(int __stdcall Real_StretchDIBits(HDC a0,
                                                   int a1,
                                                   int a2,
                                                   int a3,
                                                   int a4,
                                                   int a5,
                                                   int a6,
                                                   int a7,
                                                   int a8,
                                                   void* a9,
                                                   struct tagBITMAPINFO* a10,
                                                   UINT a11,
                                                   DWORD a12),
                  StretchDIBits);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_StringFromCLSID(IID& a0,
                                                         LPOLESTR* a1),
                  StringFromCLSID);

DETOUR_TRAMPOLINE(int __stdcall Real_StringFromGUID2(GUID& a0,
                                                     LPOLESTR a1,
                                                     int a2),
                  StringFromGUID2);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_StringFromIID(IID& a0,
                                                       LPOLESTR* a1),
                  StringFromIID);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_StrokeAndFillPath(HDC a0),
                  StrokeAndFillPath);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_StrokePath(HDC a0),
                  StrokePath);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SubtractRect(LPRECT a0,
                                                   RECT* a1,
                                                   RECT* a2),
                  SubtractRect);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_SuspendThread(HANDLE a0),
                  SuspendThread);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SwapBuffers(HDC a0),
                  SwapBuffers);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SwapMouseButton(BOOL a0),
                  SwapMouseButton);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SwitchDesktop(HDESK a0),
                  SwitchDesktop);

DETOUR_TRAMPOLINE(void __stdcall Real_SwitchToFiber(LPVOID a0),
                  SwitchToFiber);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SwitchToThread(void),
                  SwitchToThread);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SystemParametersInfoA(UINT a0,
                                                            UINT a1,
                                                            PVOID a2,
                                                            UINT a3),
                  SystemParametersInfoA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SystemParametersInfoW(UINT a0,
                                                            UINT a1,
                                                            PVOID a2,
                                                            UINT a3),
                  SystemParametersInfoW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SystemTimeToFileTime(SYSTEMTIME* a0,
                                                           LPFILETIME a1),
                  SystemTimeToFileTime);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_SystemTimeToTzSpecificLocalTime(struct _TIME_ZONE_INFORMATION* a0,
                                                                      struct _SYSTEMTIME* a1,
                                                                      struct _SYSTEMTIME* a2),
                  SystemTimeToTzSpecificLocalTime);

DETOUR_TRAMPOLINE(LONG __stdcall Real_TabbedTextOutA(HDC a0,
                                                     int a1,
                                                     int a2,
                                                     LPCSTR a3,
                                                     int a4,
                                                     int a5,
                                                     INT* a6,
                                                     int a7),
                  TabbedTextOutA);

DETOUR_TRAMPOLINE(LONG __stdcall Real_TabbedTextOutW(HDC a0,
                                                     int a1,
                                                     int a2,
                                                     LPCWSTR a3,
                                                     int a4,
                                                     int a5,
                                                     INT* a6,
                                                     int a7),
                  TabbedTextOutW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_TerminateProcess(HANDLE a0,
                                                       UINT a1),
                  TerminateProcess);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_TerminateThread(HANDLE a0,
                                                      DWORD a1),
                  TerminateThread);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_TextOutA(HDC a0,
                                               int a1,
                                               int a2,
                                               LPCSTR a3,
                                               int a4),
                  TextOutA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_TextOutW(HDC a0,
                                               int a1,
                                               int a2,
                                               LPCWSTR a3,
                                               int a4),
                  TextOutW);

DETOUR_TRAMPOLINE(WORD __stdcall Real_TileWindows(HWND a0,
                                                  UINT a1,
                                                  RECT* a2,
                                                  UINT a3,
                                                  struct HWND__** a4),
                  TileWindows);

DETOUR_TRAMPOLINE(int __stdcall Real_ToAscii(UINT a0,
                                             UINT a1,
                                             BYTE* a2,
                                             LPWORD a3,
                                             UINT a4),
                  ToAscii);

DETOUR_TRAMPOLINE(int __stdcall Real_ToAsciiEx(UINT a0,
                                               UINT a1,
                                               BYTE* a2,
                                               LPWORD a3,
                                               UINT a4,
                                               HKL a5),
                  ToAsciiEx);

DETOUR_TRAMPOLINE(int __stdcall Real_ToUnicode(UINT a0,
                                               UINT a1,
                                               BYTE* a2,
                                               LPWSTR a3,
                                               int a4,
                                               UINT a5),
                  ToUnicode);

DETOUR_TRAMPOLINE(int __stdcall Real_ToUnicodeEx(UINT a0,
                                                 UINT a1,
                                                 BYTE* a2,
                                                 LPWSTR a3,
                                                 int a4,
                                                 UINT a5,
                                                 HKL a6),
                  ToUnicodeEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_TrackMouseEvent(struct tagTRACKMOUSEEVENT* a0),
                  TrackMouseEvent);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_TrackPopupMenu(HMENU a0,
                                                     UINT a1,
                                                     int a2,
                                                     int a3,
                                                     int a4,
                                                     HWND a5,
                                                     RECT* a6),
                  TrackPopupMenu);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_TrackPopupMenuEx(HMENU a0,
                                                       UINT a1,
                                                       int a2,
                                                       int a3,
                                                       HWND a4,
                                                       LPTPMPARAMS a5),
                  TrackPopupMenuEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_TransactNamedPipe(HANDLE a0,
                                                        LPVOID a1,
                                                        DWORD a2,
                                                        LPVOID a3,
                                                        DWORD a4,
                                                        LPDWORD a5,
                                                        LPOVERLAPPED a6),
                  TransactNamedPipe);

DETOUR_TRAMPOLINE(int __stdcall Real_TranslateAcceleratorA(HWND a0,
                                                           HACCEL a1,
                                                           LPMSG a2),
                  TranslateAcceleratorA);

DETOUR_TRAMPOLINE(int __stdcall Real_TranslateAcceleratorW(HWND a0,
                                                           HACCEL a1,
                                                           LPMSG a2),
                  TranslateAcceleratorW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_TranslateCharsetInfo(DWORD* a0,
                                                           struct tagCHARSETINFO* a1,
                                                           DWORD a2),
                  TranslateCharsetInfo);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_TranslateMDISysAccel(HWND a0,
                                                           LPMSG a1),
                  TranslateMDISysAccel);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_TranslateMessage(struct tagMSG* a0),
                  TranslateMessage);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_TransmitCommChar(HANDLE a0,
                                                       char a1),
                  TransmitCommChar);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_TryEnterCriticalSection(LPCRITICAL_SECTION a0),
                  TryEnterCriticalSection);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_UnhookWindowsHook(int a0,
                                                        HOOKPROC a1),
                  UnhookWindowsHook);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_UnhookWindowsHookEx(HHOOK a0),
                  UnhookWindowsHookEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_UnionRect(LPRECT a0,
                                                RECT* a1,
                                                RECT* a2),
                  UnionRect);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_UnloadKeyboardLayout(HKL a0),
                  UnloadKeyboardLayout);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_UnlockFile(HANDLE a0,
                                                 DWORD a1,
                                                 DWORD a2,
                                                 DWORD a3,
                                                 DWORD a4),
                  UnlockFile);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_UnlockFileEx(HANDLE a0,
                                                   DWORD a1,
                                                   DWORD a2,
                                                   DWORD a3,
                                                   LPOVERLAPPED a4),
                  UnlockFileEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_UnmapViewOfFile(LPCVOID a0),
                  UnmapViewOfFile);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_UnpackDDElParam(UINT a0,
                                                      LPARAM a1,
                                                      PUINT_PTR a2,
                                                      PUINT_PTR a3),
                  UnpackDDElParam);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_UnrealizeObject(HGDIOBJ a0),
                  UnrealizeObject);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_UnregisterClassA(LPCSTR a0,
                                                       HINSTANCE a1),
                  UnregisterClassA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_UnregisterClassW(LPCWSTR a0,
                                                       HINSTANCE a1),
                  UnregisterClassW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_UnregisterHotKey(HWND a0,
                                                       int a1),
                  UnregisterHotKey);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_UpdateColors(HDC a0),
                  UpdateColors);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_UpdateICMRegKeyA(DWORD a0,
                                                       LPSTR a1,
                                                       LPSTR a2,
                                                       UINT a3),
                  UpdateICMRegKeyA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_UpdateICMRegKeyW(DWORD a0,
                                                       LPWSTR a1,
                                                       LPWSTR a2,
                                                       UINT a3),
                  UpdateICMRegKeyW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_UpdateResourceA(HANDLE a0,
                                                      LPCSTR a1,
                                                      LPCSTR a2,
                                                      WORD a3,
                                                      LPVOID a4,
                                                      DWORD a5),
                  UpdateResourceA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_UpdateResourceW(HANDLE a0,
                                                      LPCWSTR a1,
                                                      LPCWSTR a2,
                                                      WORD a3,
                                                      LPVOID a4,
                                                      DWORD a5),
                  UpdateResourceW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_UpdateWindow(HWND a0),
                  UpdateWindow);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ValidateRect(HWND a0,
                                                   RECT* a1),
                  ValidateRect);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_ValidateRgn(HWND a0,
                                                  HRGN a1),
                  ValidateRgn);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_VerLanguageNameA(DWORD a0,
                                                        LPSTR a1,
                                                        DWORD a2),
                  VerLanguageNameA);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_VerLanguageNameW(DWORD a0,
                                                        LPWSTR a1,
                                                        DWORD a2),
                  VerLanguageNameW);

DETOUR_TRAMPOLINE(LPVOID __stdcall Real_VirtualAllocEx(HANDLE a0,
                                                       LPVOID a1,
                                                       SIZE_T a2,
                                                       DWORD a3,
                                                       DWORD a4),
                  VirtualAllocEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_VirtualFreeEx(HANDLE a0,
                                                    LPVOID a1,
                                                    SIZE_T a2,
                                                    DWORD a3),
                  VirtualFreeEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_VirtualProtectEx(HANDLE a0,
                                                       LPVOID a1,
                                                       SIZE_T a2,
                                                       DWORD a3,
                                                       PDWORD a4),
                  VirtualProtectEx);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_VirtualQueryEx(HANDLE a0,
                                                      LPCVOID a1,
                                                      struct _MEMORY_BASIC_INFORMATION* a2,
                                                      DWORD a3),
                  VirtualQueryEx);

DETOUR_TRAMPOLINE(SHORT __stdcall Real_VkKeyScanA(CHAR a0),
                  VkKeyScanA);

DETOUR_TRAMPOLINE(SHORT __stdcall Real_VkKeyScanExA(CHAR a0,
                                                    HKL a1),
                  VkKeyScanExA);

DETOUR_TRAMPOLINE(SHORT __stdcall Real_VkKeyScanExW(WCHAR a0,
                                                    HKL a1),
                  VkKeyScanExW);

DETOUR_TRAMPOLINE(SHORT __stdcall Real_VkKeyScanW(WCHAR a0),
                  VkKeyScanW);

DETOUR_TRAMPOLINE(SOCKET __stdcall Real_WSAAccept(SOCKET a0,
                                                  sockaddr* a1,
                                                  LPINT a2,
                                                  LPCONDITIONPROC a3,
                                                  DWORD a4),
                  WSAAccept);

DETOUR_TRAMPOLINE(INT __stdcall Real_WSAAddressToStringA(LPSOCKADDR a0,
                                                         DWORD a1,
                                                         struct _WSAPROTOCOL_INFOA* a2,
                                                         LPSTR a3,
                                                         LPDWORD a4),
                  WSAAddressToStringA);

DETOUR_TRAMPOLINE(INT __stdcall Real_WSAAddressToStringW(LPSOCKADDR a0,
                                                         DWORD a1,
                                                         struct _WSAPROTOCOL_INFOW* a2,
                                                         LPWSTR a3,
                                                         LPDWORD a4),
                  WSAAddressToStringW);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_WSAAsyncGetHostByAddr(HWND a0,
                                                              u_int a1,
                                                              char* a2,
                                                              int a3,
                                                              int a4,
                                                              char* a5,
                                                              int a6),
                  WSAAsyncGetHostByAddr);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_WSAAsyncGetHostByName(HWND a0,
                                                              u_int a1,
                                                              char* a2,
                                                              char* a3,
                                                              int a4),
                  WSAAsyncGetHostByName);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_WSAAsyncGetProtoByName(HWND a0,
                                                               u_int a1,
                                                               char* a2,
                                                               char* a3,
                                                               int a4),
                  WSAAsyncGetProtoByName);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_WSAAsyncGetProtoByNumber(HWND a0,
                                                                 u_int a1,
                                                                 int a2,
                                                                 char* a3,
                                                                 int a4),
                  WSAAsyncGetProtoByNumber);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_WSAAsyncGetServByName(HWND a0,
                                                              u_int a1,
                                                              char* a2,
                                                              char* a3,
                                                              char* a4,
                                                              int a5),
                  WSAAsyncGetServByName);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_WSAAsyncGetServByPort(HWND a0,
                                                              u_int a1,
                                                              int a2,
                                                              char* a3,
                                                              char* a4,
                                                              int a5),
                  WSAAsyncGetServByPort);

DETOUR_TRAMPOLINE(int __stdcall Real_WSAAsyncSelect(SOCKET a0,
                                                    HWND a1,
                                                    u_int a2,
                                                    long a3),
                  WSAAsyncSelect);

DETOUR_TRAMPOLINE(int __stdcall Real_WSACancelAsyncRequest(HANDLE a0),
                  WSACancelAsyncRequest);

DETOUR_TRAMPOLINE(int __stdcall Real_WSACancelBlockingCall(void),
                  WSACancelBlockingCall);

DETOUR_TRAMPOLINE(int __stdcall Real_WSACleanup(void),
                  WSACleanup);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WSACloseEvent(HANDLE a0),
                  WSACloseEvent);

DETOUR_TRAMPOLINE(int __stdcall Real_WSAConnect(SOCKET a0,
                                                sockaddr* a1,
                                                int a2,
                                                LPWSABUF a3,
                                                LPWSABUF a4,
                                                LPQOS a5,
                                                LPQOS a6),
                  WSAConnect);

DETOUR_TRAMPOLINE(HANDLE __stdcall Real_WSACreateEvent(void),
                  WSACreateEvent);

DETOUR_TRAMPOLINE(int __stdcall Real_WSADuplicateSocketA(SOCKET a0,
                                                         DWORD a1,
                                                         struct _WSAPROTOCOL_INFOA* a2),
                  WSADuplicateSocketA);

DETOUR_TRAMPOLINE(int __stdcall Real_WSADuplicateSocketW(SOCKET a0,
                                                         DWORD a1,
                                                         struct _WSAPROTOCOL_INFOW* a2),
                  WSADuplicateSocketW);

DETOUR_TRAMPOLINE(INT __stdcall Real_WSAEnumNameSpaceProvidersA(LPDWORD a0,
                                                                LPWSANAMESPACE_INFOA a1),
                  WSAEnumNameSpaceProvidersA);

DETOUR_TRAMPOLINE(INT __stdcall Real_WSAEnumNameSpaceProvidersW(LPDWORD a0,
                                                                LPWSANAMESPACE_INFOW a1),
                  WSAEnumNameSpaceProvidersW);

DETOUR_TRAMPOLINE(int __stdcall Real_WSAEnumNetworkEvents(SOCKET a0,
                                                          HANDLE a1,
                                                          LPWSANETWORKEVENTS a2),
                  WSAEnumNetworkEvents);

DETOUR_TRAMPOLINE(int __stdcall Real_WSAEnumProtocolsA(LPINT a0,
                                                       struct _WSAPROTOCOL_INFOA* a1,
                                                       LPDWORD a2),
                  WSAEnumProtocolsA);

DETOUR_TRAMPOLINE(int __stdcall Real_WSAEnumProtocolsW(LPINT a0,
                                                       struct _WSAPROTOCOL_INFOW* a1,
                                                       LPDWORD a2),
                  WSAEnumProtocolsW);

DETOUR_TRAMPOLINE(int __stdcall Real_WSAEventSelect(SOCKET a0,
                                                    HANDLE a1,
                                                    long a2),
                  WSAEventSelect);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WSAGetOverlappedResult(SOCKET a0,
                                                             LPWSAOVERLAPPED a1,
                                                             LPDWORD a2,
                                                             BOOL a3,
                                                             LPDWORD a4),
                  WSAGetOverlappedResult);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WSAGetQOSByName(SOCKET a0,
                                                      LPWSABUF a1,
                                                      LPQOS a2),
                  WSAGetQOSByName);

DETOUR_TRAMPOLINE(INT __stdcall Real_WSAGetServiceClassInfoA(LPGUID a0,
                                                             LPGUID a1,
                                                             LPDWORD a2,
                                                             struct _WSAServiceClassInfoA* a3),
                  WSAGetServiceClassInfoA);

DETOUR_TRAMPOLINE(INT __stdcall Real_WSAGetServiceClassInfoW(LPGUID a0,
                                                             LPGUID a1,
                                                             LPDWORD a2,
                                                             struct _WSAServiceClassInfoW* a3),
                  WSAGetServiceClassInfoW);

DETOUR_TRAMPOLINE(INT __stdcall Real_WSAGetServiceClassNameByClassIdA(LPGUID a0,
                                                                      LPSTR a1,
                                                                      LPDWORD a2),
                  WSAGetServiceClassNameByClassIdA);

DETOUR_TRAMPOLINE(INT __stdcall Real_WSAGetServiceClassNameByClassIdW(LPGUID a0,
                                                                      LPWSTR a1,
                                                                      LPDWORD a2),
                  WSAGetServiceClassNameByClassIdW);

DETOUR_TRAMPOLINE(int __stdcall Real_WSAHtonl(SOCKET a0,
                                              u_long a1,
                                              u_long* a2),
                  WSAHtonl);

DETOUR_TRAMPOLINE(int __stdcall Real_WSAHtons(SOCKET a0,
                                              u_short a1,
                                              u_short* a2),
                  WSAHtons);

DETOUR_TRAMPOLINE(INT __stdcall Real_WSAInstallServiceClassA(struct _WSAServiceClassInfoA* a0),
                  WSAInstallServiceClassA);

DETOUR_TRAMPOLINE(INT __stdcall Real_WSAInstallServiceClassW(struct _WSAServiceClassInfoW* a0),
                  WSAInstallServiceClassW);

DETOUR_TRAMPOLINE(int __stdcall Real_WSAIoctl(SOCKET a0,
                                              DWORD a1,
                                              LPVOID a2,
                                              DWORD a3,
                                              LPVOID a4,
                                              DWORD a5,
                                              LPDWORD a6,
                                              LPWSAOVERLAPPED a7,
                                              LPWSAOVERLAPPED_COMPLETION_ROUTINE a8),
                  WSAIoctl);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WSAIsBlocking(void),
                  WSAIsBlocking);

DETOUR_TRAMPOLINE(SOCKET __stdcall Real_WSAJoinLeaf(SOCKET a0,
                                                    sockaddr* a1,
                                                    int a2,
                                                    LPWSABUF a3,
                                                    LPWSABUF a4,
                                                    LPQOS a5,
                                                    LPQOS a6,
                                                    DWORD a7),
                  WSAJoinLeaf);

DETOUR_TRAMPOLINE(INT __stdcall Real_WSALookupServiceBeginA(struct _WSAQuerySetA* a0,
                                                            DWORD a1,
                                                            LPHANDLE a2),
                  WSALookupServiceBeginA);

DETOUR_TRAMPOLINE(INT __stdcall Real_WSALookupServiceBeginW(struct _WSAQuerySetW* a0,
                                                            DWORD a1,
                                                            LPHANDLE a2),
                  WSALookupServiceBeginW);

DETOUR_TRAMPOLINE(INT __stdcall Real_WSALookupServiceEnd(HANDLE a0),
                  WSALookupServiceEnd);

DETOUR_TRAMPOLINE(INT __stdcall Real_WSALookupServiceNextA(HANDLE a0,
                                                           DWORD a1,
                                                           LPDWORD a2,
                                                           struct _WSAQuerySetA* a3),
                  WSALookupServiceNextA);

DETOUR_TRAMPOLINE(INT __stdcall Real_WSALookupServiceNextW(HANDLE a0,
                                                           DWORD a1,
                                                           LPDWORD a2,
                                                           struct _WSAQuerySetW* a3),
                  WSALookupServiceNextW);

DETOUR_TRAMPOLINE(int __stdcall Real_WSANtohl(SOCKET a0,
                                              u_long a1,
                                              u_long* a2),
                  WSANtohl);

DETOUR_TRAMPOLINE(int __stdcall Real_WSANtohs(SOCKET a0,
                                              u_short a1,
                                              u_short* a2),
                  WSANtohs);

DETOUR_TRAMPOLINE(INT __stdcall Real_WSAProviderConfigChange(LPHANDLE a0,
                                                             LPWSAOVERLAPPED a1,
                                                             LPWSAOVERLAPPED_COMPLETION_ROUTINE a2),
                  WSAProviderConfigChange);

DETOUR_TRAMPOLINE(int __stdcall Real_WSARecv(SOCKET a0,
                                             LPWSABUF a1,
                                             DWORD a2,
                                             LPDWORD a3,
                                             LPDWORD a4,
                                             LPWSAOVERLAPPED a5,
                                             LPWSAOVERLAPPED_COMPLETION_ROUTINE a6),
                  WSARecv);

DETOUR_TRAMPOLINE(int __stdcall Real_WSARecvDisconnect(SOCKET a0,
                                                       LPWSABUF a1),
                  WSARecvDisconnect);

DETOUR_TRAMPOLINE(int __stdcall Real_WSARecvFrom(SOCKET a0,
                                                 LPWSABUF a1,
                                                 DWORD a2,
                                                 LPDWORD a3,
                                                 LPDWORD a4,
                                                 sockaddr* a5,
                                                 LPINT a6,
                                                 LPWSAOVERLAPPED a7,
                                                 LPWSAOVERLAPPED_COMPLETION_ROUTINE a8),
                  WSARecvFrom);

DETOUR_TRAMPOLINE(INT __stdcall Real_WSARemoveServiceClass(LPGUID a0),
                  WSARemoveServiceClass);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WSAResetEvent(HANDLE a0),
                  WSAResetEvent);

DETOUR_TRAMPOLINE(int __stdcall Real_WSASend(SOCKET a0,
                                             LPWSABUF a1,
                                             DWORD a2,
                                             LPDWORD a3,
                                             DWORD a4,
                                             LPWSAOVERLAPPED a5,
                                             LPWSAOVERLAPPED_COMPLETION_ROUTINE a6),
                  WSASend);

DETOUR_TRAMPOLINE(int __stdcall Real_WSASendDisconnect(SOCKET a0,
                                                       LPWSABUF a1),
                  WSASendDisconnect);

DETOUR_TRAMPOLINE(int __stdcall Real_WSASendTo(SOCKET a0,
                                               LPWSABUF a1,
                                               DWORD a2,
                                               LPDWORD a3,
                                               DWORD a4,
                                               sockaddr* a5,
                                               int a6,
                                               LPWSAOVERLAPPED a7,
                                               LPWSAOVERLAPPED_COMPLETION_ROUTINE a8),
                  WSASendTo);

DETOUR_TRAMPOLINE(FARPROC __stdcall Real_WSASetBlockingHook(FARPROC a0),
                  WSASetBlockingHook);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WSASetEvent(HANDLE a0),
                  WSASetEvent);

DETOUR_TRAMPOLINE(INT __stdcall Real_WSASetServiceA(struct _WSAQuerySetA* a0,
                                                    WSAESETSERVICEOP a1,
                                                    DWORD a2),
                  WSASetServiceA);

DETOUR_TRAMPOLINE(INT __stdcall Real_WSASetServiceW(struct _WSAQuerySetW* a0,
                                                    WSAESETSERVICEOP a1,
                                                    DWORD a2),
                  WSASetServiceW);

DETOUR_TRAMPOLINE(SOCKET __stdcall Real_WSASocketA(int a0,
                                                   int a1,
                                                   int a2,
                                                   struct _WSAPROTOCOL_INFOA* a3,
                                                   GROUP a4,
                                                   DWORD a5),
                  WSASocketA);

DETOUR_TRAMPOLINE(SOCKET __stdcall Real_WSASocketW(int a0,
                                                   int a1,
                                                   int a2,
                                                   struct _WSAPROTOCOL_INFOW* a3,
                                                   GROUP a4,
                                                   DWORD a5),
                  WSASocketW);

DETOUR_TRAMPOLINE(int __stdcall Real_WSAStartup(WORD a0,
                                                LPWSADATA a1),
                  WSAStartup);

DETOUR_TRAMPOLINE(INT __stdcall Real_WSAStringToAddressA(LPSTR a0,
                                                         INT a1,
                                                         struct _WSAPROTOCOL_INFOA* a2,
                                                         LPSOCKADDR a3,
                                                         LPINT a4),
                  WSAStringToAddressA);

DETOUR_TRAMPOLINE(INT __stdcall Real_WSAStringToAddressW(LPWSTR a0,
                                                         INT a1,
                                                         struct _WSAPROTOCOL_INFOW* a2,
                                                         LPSOCKADDR a3,
                                                         LPINT a4),
                  WSAStringToAddressW);

DETOUR_TRAMPOLINE(int __stdcall Real_WSAUnhookBlockingHook(void),
                  WSAUnhookBlockingHook);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_WSAWaitForMultipleEvents(DWORD a0,
                                                                void** a1,
                                                                BOOL a2,
                                                                DWORD a3,
                                                                BOOL a4),
                  WSAWaitForMultipleEvents);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WaitCommEvent(HANDLE a0,
                                                    LPDWORD a1,
                                                    LPOVERLAPPED a2),
                  WaitCommEvent);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WaitForDebugEvent(struct _DEBUG_EVENT* a0,
                                                        DWORD a1),
                  WaitForDebugEvent);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_WaitForInputIdle(HANDLE a0,
                                                        DWORD a1),
                  WaitForInputIdle);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_WaitForMultipleObjects(DWORD a0,
                                                              void** a1,
                                                              BOOL a2,
                                                              DWORD a3),
                  WaitForMultipleObjects);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_WaitForMultipleObjectsEx(DWORD a0,
                                                                void** a1,
                                                                BOOL a2,
                                                                DWORD a3,
                                                                BOOL a4),
                  WaitForMultipleObjectsEx);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_WaitForSingleObject(HANDLE a0,
                                                           DWORD a1),
                  WaitForSingleObject);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_WaitForSingleObjectEx(HANDLE a0,
                                                             DWORD a1,
                                                             BOOL a2),
                  WaitForSingleObjectEx);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WaitMessage(void),
                  WaitMessage);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WaitNamedPipeA(LPCSTR a0,
                                                     DWORD a1),
                  WaitNamedPipeA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WaitNamedPipeW(LPCWSTR a0,
                                                     DWORD a1),
                  WaitNamedPipeW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WidenPath(HDC a0),
                  WidenPath);

DETOUR_TRAMPOLINE(UINT __stdcall Real_WinExec(LPCSTR a0,
                                              UINT a1),
                  WinExec);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WinHelpA(HWND a0,
                                               LPCSTR a1,
                                               UINT a2,
                                               ULONG_PTR a3),
                  WinHelpA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WinHelpW(HWND a0,
                                               LPCWSTR a1,
                                               UINT a2,
                                               ULONG_PTR a3),
                  WinHelpW);

DETOUR_TRAMPOLINE(HWND __stdcall Real_WindowFromDC(HDC a0),
                  WindowFromDC);

DETOUR_TRAMPOLINE(HWND __stdcall Real_WindowFromPoint(POINT a0),
                  WindowFromPoint);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_WriteClassStg(struct IStorage* a0,
                                                       IID& a1),
                  WriteClassStg);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_WriteClassStm(LPSTREAM a0,
                                                       IID& a1),
                  WriteClassStm);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WriteConsoleA(HANDLE a0,
                                                    void* a1,
                                                    DWORD a2,
                                                    LPDWORD a3,
                                                    LPVOID a4),
                  WriteConsoleA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WriteConsoleInputA(HANDLE a0,
                                                         INPUT_RECORD* a1,
                                                         DWORD a2,
                                                         LPDWORD a3),
                  WriteConsoleInputA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WriteConsoleInputW(HANDLE a0,
                                                         INPUT_RECORD* a1,
                                                         DWORD a2,
                                                         LPDWORD a3),
                  WriteConsoleInputW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WriteConsoleOutputA(HANDLE a0,
                                                          CHAR_INFO* a1,
                                                          COORD a2,
                                                          COORD a3,
                                                          PSMALL_RECT a4),
                  WriteConsoleOutputA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WriteConsoleOutputAttribute(HANDLE a0,
                                                                  WORD* a1,
                                                                  DWORD a2,
                                                                  COORD a3,
                                                                  LPDWORD a4),
                  WriteConsoleOutputAttribute);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WriteConsoleOutputCharacterA(HANDLE a0,
                                                                   LPCSTR a1,
                                                                   DWORD a2,
                                                                   COORD a3,
                                                                   LPDWORD a4),
                  WriteConsoleOutputCharacterA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WriteConsoleOutputCharacterW(HANDLE a0,
                                                                   LPCWSTR a1,
                                                                   DWORD a2,
                                                                   COORD a3,
                                                                   LPDWORD a4),
                  WriteConsoleOutputCharacterW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WriteConsoleOutputW(HANDLE a0,
                                                          CHAR_INFO* a1,
                                                          COORD a2,
                                                          COORD a3,
                                                          PSMALL_RECT a4),
                  WriteConsoleOutputW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WriteConsoleW(HANDLE a0,
                                                    void* a1,
                                                    DWORD a2,
                                                    LPDWORD a3,
                                                    LPVOID a4),
                  WriteConsoleW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WriteFile(HANDLE a0,
                                                LPCVOID a1,
                                                DWORD a2,
                                                LPDWORD a3,
                                                LPOVERLAPPED a4),
                  WriteFile);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WriteFileEx(HANDLE a0,
                                                  LPCVOID a1,
                                                  DWORD a2,
                                                  LPOVERLAPPED a3,
                                                  LPOVERLAPPED_COMPLETION_ROUTINE a4),
                  WriteFileEx);

DETOUR_TRAMPOLINE(HRESULT __stdcall Real_WriteFmtUserTypeStg(struct IStorage* a0,
                                                             CLIPFORMAT a1,
                                                             LPOLESTR a2),
                  WriteFmtUserTypeStg);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WritePrivateProfileSectionA(LPCSTR a0,
                                                                  LPCSTR a1,
                                                                  LPCSTR a2),
                  WritePrivateProfileSectionA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WritePrivateProfileSectionW(LPCWSTR a0,
                                                                  LPCWSTR a1,
                                                                  LPCWSTR a2),
                  WritePrivateProfileSectionW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WritePrivateProfileStringA(LPCSTR a0,
                                                                 LPCSTR a1,
                                                                 LPCSTR a2,
                                                                 LPCSTR a3),
                  WritePrivateProfileStringA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WritePrivateProfileStringW(LPCWSTR a0,
                                                                 LPCWSTR a1,
                                                                 LPCWSTR a2,
                                                                 LPCWSTR a3),
                  WritePrivateProfileStringW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WritePrivateProfileStructA(LPCSTR a0,
                                                                 LPCSTR a1,
                                                                 LPVOID a2,
                                                                 UINT a3,
                                                                 LPCSTR a4),
                  WritePrivateProfileStructA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WritePrivateProfileStructW(LPCWSTR a0,
                                                                 LPCWSTR a1,
                                                                 LPVOID a2,
                                                                 UINT a3,
                                                                 LPCWSTR a4),
                  WritePrivateProfileStructW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WriteProcessMemory(HANDLE a0,
                                                         LPVOID a1,
                                                         LPVOID a2,
                                                         DWORD a3,
                                                         LPDWORD a4),
                  WriteProcessMemory);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WriteProfileSectionA(LPCSTR a0,
                                                           LPCSTR a1),
                  WriteProfileSectionA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WriteProfileSectionW(LPCWSTR a0,
                                                           LPCWSTR a1),
                  WriteProfileSectionW);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WriteProfileStringA(LPCSTR a0,
                                                          LPCSTR a1,
                                                          LPCSTR a2),
                  WriteProfileStringA);

DETOUR_TRAMPOLINE(BOOL __stdcall Real_WriteProfileStringW(LPCWSTR a0,
                                                          LPCWSTR a1,
                                                          LPCWSTR a2),
                  WriteProfileStringW);

DETOUR_TRAMPOLINE(DWORD __stdcall Real_WriteTapemark(HANDLE a0,
                                                     DWORD a1,
                                                     DWORD a2,
                                                     BOOL a3),
                  WriteTapemark);

DETOUR_TRAMPOLINE(int __stdcall Real___WSAFDIsSet(SOCKET a0,
                                                  fd_set* a1),
                  __WSAFDIsSet);

DETOUR_TRAMPOLINE(long __stdcall Real__hread(HFILE a0,
                                             LPVOID a1,
                                             long a2),
                  _hread);

DETOUR_TRAMPOLINE(long __stdcall Real__hwrite(HFILE a0,
                                              LPCSTR a1,
                                              long a2),
                  _hwrite);

DETOUR_TRAMPOLINE(HFILE __stdcall Real__lclose(HFILE a0),
                  _lclose);

DETOUR_TRAMPOLINE(HFILE __stdcall Real__lcreat(LPCSTR a0,
                                               int a1),
                  _lcreat);

DETOUR_TRAMPOLINE(LONG __stdcall Real__llseek(HFILE a0,
                                              LONG a1,
                                              int a2),
                  _llseek);

DETOUR_TRAMPOLINE(HFILE __stdcall Real__lopen(LPCSTR a0,
                                              int a1),
                  _lopen);

DETOUR_TRAMPOLINE(UINT __stdcall Real__lread(HFILE a0,
                                             LPVOID a1,
                                             UINT a2),
                  _lread);

DETOUR_TRAMPOLINE(UINT __stdcall Real__lwrite(HFILE a0,
                                              LPCSTR a1,
                                              UINT a2),
                  _lwrite);

DETOUR_TRAMPOLINE(SOCKET __stdcall Real_accept(SOCKET a0,
                                               sockaddr* a1,
                                               int* a2),
                  accept);

DETOUR_TRAMPOLINE(int __stdcall Real_bind(SOCKET a0,
                                          sockaddr* a1,
                                          int a2),
                  bind);

DETOUR_TRAMPOLINE(int __stdcall Real_closesocket(SOCKET a0),
                  closesocket);

DETOUR_TRAMPOLINE(int __stdcall Real_connect(SOCKET a0,
                                             sockaddr* a1,
                                             int a2),
                  connect);

DETOUR_TRAMPOLINE(hostent* __stdcall Real_gethostbyaddr(char* a0,
                                                        int a1,
                                                        int a2),
                  gethostbyaddr);

DETOUR_TRAMPOLINE(hostent* __stdcall Real_gethostbyname(char* a0),
                  gethostbyname);

DETOUR_TRAMPOLINE(int __stdcall Real_gethostname(char* a0,
                                                 int a1),
                  gethostname);

DETOUR_TRAMPOLINE(int __stdcall Real_getpeername(SOCKET a0,
                                                 sockaddr* a1,
                                                 int* a2),
                  getpeername);

DETOUR_TRAMPOLINE(protoent* __stdcall Real_getprotobyname(char* a0),
                  getprotobyname);

DETOUR_TRAMPOLINE(protoent* __stdcall Real_getprotobynumber(int a0),
                  getprotobynumber);

DETOUR_TRAMPOLINE(servent* __stdcall Real_getservbyname(char* a0,
                                                        char* a1),
                  getservbyname);

DETOUR_TRAMPOLINE(servent* __stdcall Real_getservbyport(int a0,
                                                        char* a1),
                  getservbyport);

DETOUR_TRAMPOLINE(int __stdcall Real_getsockname(SOCKET a0,
                                                 sockaddr* a1,
                                                 int* a2),
                  getsockname);

DETOUR_TRAMPOLINE(int __stdcall Real_getsockopt(SOCKET a0,
                                                int a1,
                                                int a2,
                                                char* a3,
                                                int* a4),
                  getsockopt);

DETOUR_TRAMPOLINE(u_long __stdcall Real_htonl(u_long a0),
                  htonl);

DETOUR_TRAMPOLINE(u_short __stdcall Real_htons(u_short a0),
                  htons);

DETOUR_TRAMPOLINE(unsigned long __stdcall Real_inet_addr(char* a0),
                  inet_addr);

DETOUR_TRAMPOLINE(char* __stdcall Real_inet_ntoa(in_addr a0),
                  inet_ntoa);

DETOUR_TRAMPOLINE(int __stdcall Real_ioctlsocket(SOCKET a0,
                                                 long a1,
                                                 u_long* a2),
                  ioctlsocket);

DETOUR_TRAMPOLINE(void __stdcall Real_keybd_event(BYTE a0,
                                                  BYTE a1,
                                                  DWORD a2,
                                                  ULONG_PTR a3),
                  keybd_event);

DETOUR_TRAMPOLINE(int __stdcall Real_listen(SOCKET a0,
                                            int a1),
                  listen);

DETOUR_TRAMPOLINE(LPSTR __stdcall Real_lstrcatA(LPSTR a0,
                                                LPCSTR a1),
                  lstrcatA);

DETOUR_TRAMPOLINE(LPWSTR __stdcall Real_lstrcatW(LPWSTR a0,
                                                 LPCWSTR a1),
                  lstrcatW);

DETOUR_TRAMPOLINE(int __stdcall Real_lstrcmpA(LPCSTR a0,
                                              LPCSTR a1),
                  lstrcmpA);

DETOUR_TRAMPOLINE(int __stdcall Real_lstrcmpW(LPCWSTR a0,
                                              LPCWSTR a1),
                  lstrcmpW);

DETOUR_TRAMPOLINE(int __stdcall Real_lstrcmpiA(LPCSTR a0,
                                               LPCSTR a1),
                  lstrcmpiA);

DETOUR_TRAMPOLINE(int __stdcall Real_lstrcmpiW(LPCWSTR a0,
                                               LPCWSTR a1),
                  lstrcmpiW);

DETOUR_TRAMPOLINE(LPSTR __stdcall Real_lstrcpyA(LPSTR a0,
                                                LPCSTR a1),
                  lstrcpyA);

DETOUR_TRAMPOLINE(LPWSTR __stdcall Real_lstrcpyW(LPWSTR a0,
                                                 LPCWSTR a1),
                  lstrcpyW);

DETOUR_TRAMPOLINE(LPSTR __stdcall Real_lstrcpynA(LPSTR a0,
                                                 LPCSTR a1,
                                                 int a2),
                  lstrcpynA);

DETOUR_TRAMPOLINE(LPWSTR __stdcall Real_lstrcpynW(LPWSTR a0,
                                                  LPCWSTR a1,
                                                  int a2),
                  lstrcpynW);

DETOUR_TRAMPOLINE(int __stdcall Real_lstrlenA(LPCSTR a0),
                  lstrlenA);

DETOUR_TRAMPOLINE(int __stdcall Real_lstrlenW(LPCWSTR a0),
                  lstrlenW);

DETOUR_TRAMPOLINE(void __stdcall Real_mouse_event(DWORD a0,
                                                  DWORD a1,
                                                  DWORD a2,
                                                  DWORD a3,
                                                  ULONG_PTR a4),
                  mouse_event);

DETOUR_TRAMPOLINE(u_long __stdcall Real_ntohl(u_long a0),
                  ntohl);

DETOUR_TRAMPOLINE(u_short __stdcall Real_ntohs(u_short a0),
                  ntohs);

DETOUR_TRAMPOLINE(int __stdcall Real_recv(SOCKET a0,
                                          char* a1,
                                          int a2,
                                          int a3),
                  recv);

DETOUR_TRAMPOLINE(int __stdcall Real_recvfrom(SOCKET a0,
                                              char* a1,
                                              int a2,
                                              int a3,
                                              sockaddr* a4,
                                              int* a5),
                  recvfrom);

DETOUR_TRAMPOLINE(int __stdcall Real_select(int a0,
                                            fd_set* a1,
                                            fd_set* a2,
                                            fd_set* a3,
                                            timeval* a4),
                  select);

DETOUR_TRAMPOLINE(int __stdcall Real_send(SOCKET a0,
                                          char* a1,
                                          int a2,
                                          int a3),
                  send);

DETOUR_TRAMPOLINE(int __stdcall Real_sendto(SOCKET a0,
                                            char* a1,
                                            int a2,
                                            int a3,
                                            sockaddr* a4,
                                            int a5),
                  sendto);

DETOUR_TRAMPOLINE(int __stdcall Real_setsockopt(SOCKET a0,
                                                int a1,
                                                int a2,
                                                char* a3,
                                                int a4),
                  setsockopt);

DETOUR_TRAMPOLINE(int __stdcall Real_shutdown(SOCKET a0,
                                              int a1),
                  shutdown);

DETOUR_TRAMPOLINE(SOCKET __stdcall Real_socket(int a0,
                                               int a1,
                                               int a2),
                  socket);

///////////////////////////////////////////////////////////////////// Detours.
//

int __stdcall Mine_AbortDoc(HDC a0)
{
    _PrintEnter("AbortDoc(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_AbortDoc(a0);
    } __finally {
        _PrintExit("AbortDoc() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_AbortPath(HDC a0)
{
    _PrintEnter("AbortPath(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_AbortPath(a0);
    } __finally {
        _PrintExit("AbortPath() -> %lx\n", rv);
    };
    return rv;
}

HKL __stdcall Mine_ActivateKeyboardLayout(HKL a0,
                                          UINT a1)
{
    _PrintEnter("ActivateKeyboardLayout(%lx,%lx)\n", a0, a1);

    HKL rv = 0;
    __try {
        rv = Real_ActivateKeyboardLayout(a0, a1);
    } __finally {
        _PrintExit("ActivateKeyboardLayout(,) -> %lx\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_AddAtomA(LPCSTR a0)
{
    _PrintEnter("AddAtomA(%hs)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_AddAtomA(a0);
    } __finally {
        _PrintExit("AddAtomA() -> %lx\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_AddAtomW(LPCWSTR a0)
{
    _PrintEnter("AddAtomW(%ls)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_AddAtomW(a0);
    } __finally {
        _PrintExit("AddAtomW() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_AddFontResourceA(LPCSTR a0)
{
    _PrintEnter("AddFontResourceA(%hs)\n", a0);

    int rv = 0;
    __try {
        rv = Real_AddFontResourceA(a0);
    } __finally {
        _PrintExit("AddFontResourceA() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_AddFontResourceW(LPCWSTR a0)
{
    _PrintEnter("AddFontResourceW(%ls)\n", a0);

    int rv = 0;
    __try {
        rv = Real_AddFontResourceW(a0);
    } __finally {
        _PrintExit("AddFontResourceW() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_AdjustWindowRect(LPRECT a0,
                                     DWORD a1,
                                     BOOL a2)
{
    _PrintEnter("AdjustWindowRect(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_AdjustWindowRect(a0, a1, a2);
    } __finally {
        _PrintExit("AdjustWindowRect(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_AdjustWindowRectEx(LPRECT a0,
                                       DWORD a1,
                                       BOOL a2,
                                       DWORD a3)
{
    _PrintEnter("AdjustWindowRectEx(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_AdjustWindowRectEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("AdjustWindowRectEx(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_AllocConsole(void)
{
    _PrintEnter("AllocConsole()\n");

    BOOL rv = 0;
    __try {
        rv = Real_AllocConsole();
    } __finally {
        _PrintExit("AllocConsole() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_AngleArc(HDC a0,
                             int a1,
                             int a2,
                             DWORD a3,
                             FLOAT a4,
                             FLOAT a5)
{
    _PrintEnter("AngleArc(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_AngleArc(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("AngleArc(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_AnimatePalette(HPALETTE a0,
                                   UINT a1,
                                   UINT a2,
                                   PALETTEENTRY* a3)
{
    _PrintEnter("AnimatePalette(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_AnimatePalette(a0, a1, a2, a3);
    } __finally {
        _PrintExit("AnimatePalette(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_AnyPopup(void)
{
    _PrintEnter("AnyPopup()\n");

    BOOL rv = 0;
    __try {
        rv = Real_AnyPopup();
    } __finally {
        _PrintExit("AnyPopup() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_AppendMenuA(HMENU a0,
                                UINT a1,
                                UINT_PTR a2,
                                LPCSTR a3)
{
    _PrintEnter("AppendMenuA(%lx,%lx,%lx,%hs)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_AppendMenuA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("AppendMenuA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_AppendMenuW(HMENU a0,
                                UINT a1,
                                UINT_PTR a2,
                                LPCWSTR a3)
{
    _PrintEnter("AppendMenuW(%lx,%lx,%lx,%ls)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_AppendMenuW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("AppendMenuW(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_Arc(HDC a0,
                        int a1,
                        int a2,
                        int a3,
                        int a4,
                        int a5,
                        int a6,
                        int a7,
                        int a8)
{
    _PrintEnter("Arc(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8);

    BOOL rv = 0;
    __try {
        rv = Real_Arc(a0, a1, a2, a3, a4, a5, a6, a7, a8);
    } __finally {
        _PrintExit("Arc(,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ArcTo(HDC a0,
                          int a1,
                          int a2,
                          int a3,
                          int a4,
                          int a5,
                          int a6,
                          int a7,
                          int a8)
{
    _PrintEnter("ArcTo(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8);

    BOOL rv = 0;
    __try {
        rv = Real_ArcTo(a0, a1, a2, a3, a4, a5, a6, a7, a8);
    } __finally {
        _PrintExit("ArcTo(,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_AreFileApisANSI(void)
{
    _PrintEnter("AreFileApisANSI()\n");

    BOOL rv = 0;
    __try {
        rv = Real_AreFileApisANSI();
    } __finally {
        _PrintExit("AreFileApisANSI() -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_ArrangeIconicWindows(HWND a0)
{
    _PrintEnter("ArrangeIconicWindows(%lx)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_ArrangeIconicWindows(a0);
    } __finally {
        _PrintExit("ArrangeIconicWindows() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_AttachThreadInput(DWORD a0,
                                      DWORD a1,
                                      BOOL a2)
{
    _PrintEnter("AttachThreadInput(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_AttachThreadInput(a0, a1, a2);
    } __finally {
        _PrintExit("AttachThreadInput(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_BackupRead(HANDLE a0,
                               LPBYTE a1,
                               DWORD a2,
                               LPDWORD a3,
                               BOOL a4,
                               BOOL a5,
                               LPVOID* a6)
{
    _PrintEnter("BackupRead(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_BackupRead(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("BackupRead(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_BackupSeek(HANDLE a0,
                               DWORD a1,
                               DWORD a2,
                               LPDWORD a3,
                               LPDWORD a4,
                               LPVOID* a5)
{
    _PrintEnter("BackupSeek(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_BackupSeek(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("BackupSeek(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_BackupWrite(HANDLE a0,
                                LPBYTE a1,
                                DWORD a2,
                                LPDWORD a3,
                                BOOL a4,
                                BOOL a5,
                                LPVOID* a6)
{
    _PrintEnter("BackupWrite(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_BackupWrite(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("BackupWrite(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_Beep(DWORD a0,
                         DWORD a1)
{
    _PrintEnter("Beep(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_Beep(a0, a1);
    } __finally {
        _PrintExit("Beep(,) -> %lx\n", rv);
    };
    return rv;
}

HDWP __stdcall Mine_BeginDeferWindowPos(int a0)
{
    _PrintEnter("BeginDeferWindowPos(%lx)\n", a0);

    HDWP rv = 0;
    __try {
        rv = Real_BeginDeferWindowPos(a0);
    } __finally {
        _PrintExit("BeginDeferWindowPos() -> %lx\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_BeginPaint(HWND a0,
                              LPPAINTSTRUCT a1)
{
    _PrintEnter("BeginPaint(%lx,%lx)\n", a0, a1);

    HDC rv = 0;
    __try {
        rv = Real_BeginPaint(a0, a1);
    } __finally {
        _PrintExit("BeginPaint(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_BeginPath(HDC a0)
{
    _PrintEnter("BeginPath(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_BeginPath(a0);
    } __finally {
        _PrintExit("BeginPath() -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_BeginUpdateResourceA(LPCSTR a0,
                                           BOOL a1)
{
    _PrintEnter("BeginUpdateResourceA(%hs,%lx)\n", a0, a1);

    HANDLE rv = 0;
    __try {
        rv = Real_BeginUpdateResourceA(a0, a1);
    } __finally {
        _PrintExit("BeginUpdateResourceA(,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_BeginUpdateResourceW(LPCWSTR a0,
                                           BOOL a1)
{
    _PrintEnter("BeginUpdateResourceW(%ls,%lx)\n", a0, a1);

    HANDLE rv = 0;
    __try {
        rv = Real_BeginUpdateResourceW(a0, a1);
    } __finally {
        _PrintExit("BeginUpdateResourceW(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_BindMoniker(struct IMoniker* a0,
                                   DWORD a1,
                                   IID& a2,
                                   LPVOID* a3)
{
    _PrintEnter("BindMoniker(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_BindMoniker(a0, a1, a2, a3);
    } __finally {
        _PrintExit("BindMoniker(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_BitBlt(HDC a0,
                           int a1,
                           int a2,
                           int a3,
                           int a4,
                           HDC a5,
                           int a6,
                           int a7,
                           DWORD a8)
{
    _PrintEnter("BitBlt(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8);

    BOOL rv = 0;
    __try {
        rv = Real_BitBlt(a0, a1, a2, a3, a4, a5, a6, a7, a8);
    } __finally {
        _PrintExit("BitBlt(,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_BringWindowToTop(HWND a0)
{
    _PrintEnter("BringWindowToTop(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_BringWindowToTop(a0);
    } __finally {
        _PrintExit("BringWindowToTop() -> %lx\n", rv);
    };
    return rv;
}

long __stdcall Mine_BroadcastSystemMessageA(DWORD a0,
                                            LPDWORD a1,
                                            UINT a2,
                                            WPARAM a3,
                                            LPARAM a4)
{
    _PrintEnter("BroadcastSystemMessageA(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    long rv = 0;
    __try {
        rv = Real_BroadcastSystemMessageA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("BroadcastSystemMessageA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

long __stdcall Mine_BroadcastSystemMessageW(DWORD a0,
                                            LPDWORD a1,
                                            UINT a2,
                                            WPARAM a3,
                                            LPARAM a4)
{
    _PrintEnter("BroadcastSystemMessageW(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    long rv = 0;
    __try {
        rv = Real_BroadcastSystemMessageW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("BroadcastSystemMessageW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_BuildCommDCBA(LPCSTR a0,
                                  struct _DCB* a1)
{
    _PrintEnter("BuildCommDCBA(%hs,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_BuildCommDCBA(a0, a1);
    } __finally {
        _PrintExit("BuildCommDCBA(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_BuildCommDCBAndTimeoutsA(LPCSTR a0,
                                             struct _DCB* a1,
                                             struct _COMMTIMEOUTS* a2)
{
    _PrintEnter("BuildCommDCBAndTimeoutsA(%hs,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_BuildCommDCBAndTimeoutsA(a0, a1, a2);
    } __finally {
        _PrintExit("BuildCommDCBAndTimeoutsA(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_BuildCommDCBAndTimeoutsW(LPCWSTR a0,
                                             struct _DCB* a1,
                                             struct _COMMTIMEOUTS* a2)
{
    _PrintEnter("BuildCommDCBAndTimeoutsW(%ls,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_BuildCommDCBAndTimeoutsW(a0, a1, a2);
    } __finally {
        _PrintExit("BuildCommDCBAndTimeoutsW(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_BuildCommDCBW(LPCWSTR a0,
                                  struct _DCB* a1)
{
    _PrintEnter("BuildCommDCBW(%ls,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_BuildCommDCBW(a0, a1);
    } __finally {
        _PrintExit("BuildCommDCBW(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CLSIDFromProgID(LPCOLESTR a0,
                                       struct _GUID* a1)
{
    _PrintEnter("CLSIDFromProgID(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CLSIDFromProgID(a0, a1);
    } __finally {
        _PrintExit("CLSIDFromProgID(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CLSIDFromString(LPOLESTR a0,
                                       struct _GUID* a1)
{
    _PrintEnter("CLSIDFromString(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CLSIDFromString(a0, a1);
    } __finally {
        _PrintExit("CLSIDFromString(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CallMsgFilterA(LPMSG a0,
                                   int a1)
{
    _PrintEnter("CallMsgFilterA(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_CallMsgFilterA(a0, a1);
    } __finally {
        _PrintExit("CallMsgFilterA(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CallMsgFilterW(LPMSG a0,
                                   int a1)
{
    _PrintEnter("CallMsgFilterW(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_CallMsgFilterW(a0, a1);
    } __finally {
        _PrintExit("CallMsgFilterW(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CallNamedPipeA(LPCSTR a0,
                                   LPVOID a1,
                                   DWORD a2,
                                   LPVOID a3,
                                   DWORD a4,
                                   LPDWORD a5,
                                   DWORD a6)
{
    _PrintEnter("CallNamedPipeA(%hs,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_CallNamedPipeA(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("CallNamedPipeA(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CallNamedPipeW(LPCWSTR a0,
                                   LPVOID a1,
                                   DWORD a2,
                                   LPVOID a3,
                                   DWORD a4,
                                   LPDWORD a5,
                                   DWORD a6)
{
    _PrintEnter("CallNamedPipeW(%ls,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_CallNamedPipeW(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("CallNamedPipeW(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_CallNextHookEx(HHOOK a0,
                                      int a1,
                                      WPARAM a2,
                                      LPARAM a3)
{
    _PrintEnter("CallNextHookEx(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    LRESULT rv = 0;
    __try {
        rv = Real_CallNextHookEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CallNextHookEx(,,,) -> %lx\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_CallWindowProcA(WNDPROC a0,
                                       HWND a1,
                                       UINT a2,
                                       WPARAM a3,
                                       LPARAM a4)
{
    _PrintEnter("CallWindowProcA(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    LRESULT rv = 0;
    __try {
        rv = Real_CallWindowProcA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CallWindowProcA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_CallWindowProcW(WNDPROC a0,
                                       HWND a1,
                                       UINT a2,
                                       WPARAM a3,
                                       LPARAM a4)
{
    _PrintEnter("CallWindowProcW(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    LRESULT rv = 0;
    __try {
        rv = Real_CallWindowProcW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CallWindowProcW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CancelDC(HDC a0)
{
    _PrintEnter("CancelDC(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_CancelDC(a0);
    } __finally {
        _PrintExit("CancelDC() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CancelIo(HANDLE a0)
{
    _PrintEnter("CancelIo(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_CancelIo(a0);
    } __finally {
        _PrintExit("CancelIo() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CancelWaitableTimer(HANDLE a0)
{
    _PrintEnter("CancelWaitableTimer(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_CancelWaitableTimer(a0);
    } __finally {
        _PrintExit("CancelWaitableTimer() -> %lx\n", rv);
    };
    return rv;
}

WORD __stdcall Mine_CascadeWindows(HWND a0,
                                   UINT a1,
                                   RECT* a2,
                                   UINT a3,
                                   struct HWND__** a4)
{
    _PrintEnter("CascadeWindows(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    WORD rv = 0;
    __try {
        rv = Real_CascadeWindows(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CascadeWindows(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ChangeClipboardChain(HWND a0,
                                         HWND a1)
{
    _PrintEnter("ChangeClipboardChain(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_ChangeClipboardChain(a0, a1);
    } __finally {
        _PrintExit("ChangeClipboardChain(,) -> %lx\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_ChangeDisplaySettingsA(LPDEVMODEA a0,
                                           DWORD a1)
{
    _PrintEnter("ChangeDisplaySettingsA(%lx,%lx)\n", a0, a1);

    LONG rv = 0;
    __try {
        rv = Real_ChangeDisplaySettingsA(a0, a1);
    } __finally {
        _PrintExit("ChangeDisplaySettingsA(,) -> %lx\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_ChangeDisplaySettingsExA(LPCSTR a0,
                                             LPDEVMODEA a1,
                                             HWND a2,
                                             DWORD a3,
                                             LPVOID a4)
{
    _PrintEnter("ChangeDisplaySettingsExA(%hs,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    LONG rv = 0;
    __try {
        rv = Real_ChangeDisplaySettingsExA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ChangeDisplaySettingsExA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_ChangeDisplaySettingsExW(LPCWSTR a0,
                                             LPDEVMODEW a1,
                                             HWND a2,
                                             DWORD a3,
                                             LPVOID a4)
{
    _PrintEnter("ChangeDisplaySettingsExW(%ls,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    LONG rv = 0;
    __try {
        rv = Real_ChangeDisplaySettingsExW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ChangeDisplaySettingsExW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_ChangeDisplaySettingsW(LPDEVMODEW a0,
                                           DWORD a1)
{
    _PrintEnter("ChangeDisplaySettingsW(%lx,%lx)\n", a0, a1);

    LONG rv = 0;
    __try {
        rv = Real_ChangeDisplaySettingsW(a0, a1);
    } __finally {
        _PrintExit("ChangeDisplaySettingsW(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ChangeMenuA(HMENU a0,
                                UINT a1,
                                LPCSTR a2,
                                UINT a3,
                                UINT a4)
{
    _PrintEnter("ChangeMenuA(%lx,%lx,%hs,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ChangeMenuA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ChangeMenuA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ChangeMenuW(HMENU a0,
                                UINT a1,
                                LPCWSTR a2,
                                UINT a3,
                                UINT a4)
{
    _PrintEnter("ChangeMenuW(%lx,%lx,%ls,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ChangeMenuW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ChangeMenuW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

LPSTR __stdcall Mine_CharLowerA(LPSTR a0)
{
    _PrintEnter("CharLowerA(%hs)\n", a0);

    LPSTR rv = 0;
    __try {
        rv = Real_CharLowerA(a0);
    } __finally {
        _PrintExit("CharLowerA(%hs) -> %hs\n", a0, rv);
    };
    return rv;
}

DWORD __stdcall Mine_CharLowerBuffA(LPSTR a0,
                                    DWORD a1)
{
    _PrintEnter("CharLowerBuffA(%hs,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_CharLowerBuffA(a0, a1);
    } __finally {
        _PrintExit("CharLowerBuffA(%hs,) -> %lx\n", a0, rv);
    };
    return rv;
}

DWORD __stdcall Mine_CharLowerBuffW(LPWSTR a0,
                                    DWORD a1)
{
    _PrintEnter("CharLowerBuffW(%ls,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_CharLowerBuffW(a0, a1);
    } __finally {
        _PrintExit("CharLowerBuffW(%ls,) -> %lx\n", a0, rv);
    };
    return rv;
}

LPWSTR __stdcall Mine_CharLowerW(LPWSTR a0)
{
    _PrintEnter("CharLowerW(%ls)\n", a0);

    LPWSTR rv = 0;
    __try {
        rv = Real_CharLowerW(a0);
    } __finally {
        _PrintExit("CharLowerW(%ls) -> %ls\n", a0, rv);
    };
    return rv;
}

LPSTR __stdcall Mine_CharNextA(LPCSTR a0)
{
    _PrintEnter("CharNextA(%hs)\n", a0);

    LPSTR rv = 0;
    __try {
        rv = Real_CharNextA(a0);
    } __finally {
        _PrintExit("CharNextA() -> %hs\n", rv);
    };
    return rv;
}

LPSTR __stdcall Mine_CharNextExA(WORD a0,
                                 LPCSTR a1,
                                 DWORD a2)
{
    _PrintEnter("CharNextExA(%lx,%hs,%lx)\n", a0, a1, a2);

    LPSTR rv = 0;
    __try {
        rv = Real_CharNextExA(a0, a1, a2);
    } __finally {
        _PrintExit("CharNextExA(,,) -> %hs\n", rv);
    };
    return rv;
}

LPWSTR __stdcall Mine_CharNextW(LPCWSTR a0)
{
    _PrintEnter("CharNextW(%ls)\n", a0);

    LPWSTR rv = 0;
    __try {
        rv = Real_CharNextW(a0);
    } __finally {
        _PrintExit("CharNextW() -> %ls\n", rv);
    };
    return rv;
}

LPSTR __stdcall Mine_CharPrevA(LPCSTR a0,
                               LPCSTR a1)
{
    _PrintEnter("CharPrevA(%hs,%hs)\n", a0, a1);

    LPSTR rv = 0;
    __try {
        rv = Real_CharPrevA(a0, a1);
    } __finally {
        _PrintExit("CharPrevA(,) -> %hs\n", rv);
    };
    return rv;
}

LPSTR __stdcall Mine_CharPrevExA(WORD a0,
                                 LPCSTR a1,
                                 LPCSTR a2,
                                 DWORD a3)
{
    _PrintEnter("CharPrevExA(%lx,%hs,%hs,%lx)\n", a0, a1, a2, a3);

    LPSTR rv = 0;
    __try {
        rv = Real_CharPrevExA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CharPrevExA(,,,) -> %hs\n", rv);
    };
    return rv;
}

LPWSTR __stdcall Mine_CharPrevW(LPCWSTR a0,
                                LPCWSTR a1)
{
    _PrintEnter("CharPrevW(%ls,%ls)\n", a0, a1);

    LPWSTR rv = 0;
    __try {
        rv = Real_CharPrevW(a0, a1);
    } __finally {
        _PrintExit("CharPrevW(,) -> %ls\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CharToOemA(LPCSTR a0,
                               LPSTR a1)
{
    _PrintEnter("CharToOemA(%hs,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_CharToOemA(a0, a1);
    } __finally {
        _PrintExit("CharToOemA(,%hs) -> %lx\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_CharToOemBuffA(LPCSTR a0,
                                   LPSTR a1,
                                   DWORD a2)
{
    _PrintEnter("CharToOemBuffA(%hs,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_CharToOemBuffA(a0, a1, a2);
    } __finally {
        _PrintExit("CharToOemBuffA(,%hs,) -> %lx\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_CharToOemBuffW(LPCWSTR a0,
                                   LPSTR a1,
                                   DWORD a2)
{
    _PrintEnter("CharToOemBuffW(%ls,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_CharToOemBuffW(a0, a1, a2);
    } __finally {
        _PrintExit("CharToOemBuffW(,%hs,) -> %lx\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_CharToOemW(LPCWSTR a0,
                               LPSTR a1)
{
    _PrintEnter("CharToOemW(%ls,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_CharToOemW(a0, a1);
    } __finally {
        _PrintExit("CharToOemW(,%hs) -> %lx\n", a1, rv);
    };
    return rv;
}

LPSTR __stdcall Mine_CharUpperA(LPSTR a0)
{
    _PrintEnter("CharUpperA(%hs)\n", a0);

    LPSTR rv = 0;
    __try {
        rv = Real_CharUpperA(a0);
    } __finally {
        _PrintExit("CharUpperA(%hs) -> %hs\n", a0, rv);
    };
    return rv;
}

DWORD __stdcall Mine_CharUpperBuffA(LPSTR a0,
                                    DWORD a1)
{
    _PrintEnter("CharUpperBuffA(%hs,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_CharUpperBuffA(a0, a1);
    } __finally {
        _PrintExit("CharUpperBuffA(%hs,) -> %lx\n", a0, rv);
    };
    return rv;
}

DWORD __stdcall Mine_CharUpperBuffW(LPWSTR a0,
                                    DWORD a1)
{
    _PrintEnter("CharUpperBuffW(%ls,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_CharUpperBuffW(a0, a1);
    } __finally {
        _PrintExit("CharUpperBuffW(%ls,) -> %lx\n", a0, rv);
    };
    return rv;
}

LPWSTR __stdcall Mine_CharUpperW(LPWSTR a0)
{
    _PrintEnter("CharUpperW(%ls)\n", a0);

    LPWSTR rv = 0;
    __try {
        rv = Real_CharUpperW(a0);
    } __finally {
        _PrintExit("CharUpperW(%ls) -> %ls\n", a0, rv);
    };
    return rv;
}

BOOL __stdcall Mine_CheckColorsInGamut(HDC a0,
                                       LPVOID a1,
                                       LPVOID a2,
                                       DWORD a3)
{
    _PrintEnter("CheckColorsInGamut(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_CheckColorsInGamut(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CheckColorsInGamut(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CheckDlgButton(HWND a0,
                                   int a1,
                                   UINT a2)
{
    _PrintEnter("CheckDlgButton(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_CheckDlgButton(a0, a1, a2);
    } __finally {
        _PrintExit("CheckDlgButton(,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_CheckMenuItem(HMENU a0,
                                   UINT a1,
                                   UINT a2)
{
    _PrintEnter("CheckMenuItem(%lx,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_CheckMenuItem(a0, a1, a2);
    } __finally {
        _PrintExit("CheckMenuItem(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CheckMenuRadioItem(HMENU a0,
                                       UINT a1,
                                       UINT a2,
                                       UINT a3,
                                       UINT a4)
{
    _PrintEnter("CheckMenuRadioItem(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_CheckMenuRadioItem(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CheckMenuRadioItem(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CheckRadioButton(HWND a0,
                                     int a1,
                                     int a2,
                                     int a3)
{
    _PrintEnter("CheckRadioButton(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_CheckRadioButton(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CheckRadioButton(,,,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_ChildWindowFromPoint(HWND a0,
                                         POINT a1)
{
    _PrintEnter("ChildWindowFromPoint(%lx,%lx)\n", a0, a1);

    HWND rv = 0;
    __try {
        rv = Real_ChildWindowFromPoint(a0, a1);
    } __finally {
        _PrintExit("ChildWindowFromPoint(,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_ChildWindowFromPointEx(HWND a0,
                                           POINT a1,
                                           UINT a2)
{
    _PrintEnter("ChildWindowFromPointEx(%lx,%lx,%lx)\n", a0, a1, a2);

    HWND rv = 0;
    __try {
        rv = Real_ChildWindowFromPointEx(a0, a1, a2);
    } __finally {
        _PrintExit("ChildWindowFromPointEx(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_ChoosePixelFormat(HDC a0,
                                     PIXELFORMATDESCRIPTOR* a1)
{
    _PrintEnter("ChoosePixelFormat(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_ChoosePixelFormat(a0, a1);
    } __finally {
        _PrintExit("ChoosePixelFormat(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_Chord(HDC a0,
                          int a1,
                          int a2,
                          int a3,
                          int a4,
                          int a5,
                          int a6,
                          int a7,
                          int a8)
{
    _PrintEnter("Chord(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8);

    BOOL rv = 0;
    __try {
        rv = Real_Chord(a0, a1, a2, a3, a4, a5, a6, a7, a8);
    } __finally {
        _PrintExit("Chord(,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ClearCommBreak(HANDLE a0)
{
    _PrintEnter("ClearCommBreak(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_ClearCommBreak(a0);
    } __finally {
        _PrintExit("ClearCommBreak() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ClearCommError(HANDLE a0,
                                   LPDWORD a1,
                                   struct _COMSTAT* a2)
{
    _PrintEnter("ClearCommError(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_ClearCommError(a0, a1, a2);
    } __finally {
        _PrintExit("ClearCommError(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ClientToScreen(HWND a0,
                                   struct tagPOINT* a1)
{
    _PrintEnter("ClientToScreen(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_ClientToScreen(a0, a1);
    } __finally {
        _PrintExit("ClientToScreen(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ClipCursor(RECT* a0)
{
    _PrintEnter("ClipCursor(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_ClipCursor(a0);
    } __finally {
        _PrintExit("ClipCursor() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CloseClipboard(void)
{
    _PrintEnter("CloseClipboard()\n");

    BOOL rv = 0;
    __try {
        rv = Real_CloseClipboard();
    } __finally {
        _PrintExit("CloseClipboard() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CloseDesktop(HDESK a0)
{
    _PrintEnter("CloseDesktop(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_CloseDesktop(a0);
    } __finally {
        _PrintExit("CloseDesktop() -> %lx\n", rv);
    };
    return rv;
}

HENHMETAFILE __stdcall Mine_CloseEnhMetaFile(HDC a0)
{
    _PrintEnter("CloseEnhMetaFile(%lx)\n", a0);

    HENHMETAFILE rv = 0;
    __try {
        rv = Real_CloseEnhMetaFile(a0);
    } __finally {
        _PrintExit("CloseEnhMetaFile() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CloseFigure(HDC a0)
{
    _PrintEnter("CloseFigure(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_CloseFigure(a0);
    } __finally {
        _PrintExit("CloseFigure() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CloseHandle(HANDLE a0)
{
    _PrintEnter("CloseHandle(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_CloseHandle(a0);
    } __finally {
        _PrintExit("CloseHandle() -> %lx\n", rv);
    };
    return rv;
}

HMETAFILE __stdcall Mine_CloseMetaFile(HDC a0)
{
    _PrintEnter("CloseMetaFile(%lx)\n", a0);

    HMETAFILE rv = 0;
    __try {
        rv = Real_CloseMetaFile(a0);
    } __finally {
        _PrintExit("CloseMetaFile() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CloseWindow(HWND a0)
{
    _PrintEnter("CloseWindow(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_CloseWindow(a0);
    } __finally {
        _PrintExit("CloseWindow() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CloseWindowStation(HWINSTA a0)
{
    _PrintEnter("CloseWindowStation(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_CloseWindowStation(a0);
    } __finally {
        _PrintExit("CloseWindowStation() -> %lx\n", rv);
    };
    return rv;
}

ULONG __stdcall Mine_CoAddRefServerProcess(void)
{
    _PrintEnter("CoAddRefServerProcess()\n");

    ULONG rv = 0;
    __try {
        rv = Real_CoAddRefServerProcess();
    } __finally {
        _PrintExit("CoAddRefServerProcess() -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_CoBuildVersion(void)
{
    _PrintEnter("CoBuildVersion()\n");

    DWORD rv = 0;
    __try {
        rv = Real_CoBuildVersion();
    } __finally {
        _PrintExit("CoBuildVersion() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoCopyProxy(IUnknown* a0,
                                   IUnknown** a1)
{
    _PrintEnter("CoCopyProxy(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoCopyProxy(a0, a1);
    } __finally {
        _PrintExit("CoCopyProxy(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoCreateFreeThreadedMarshaler(LPUNKNOWN a0,
                                                     LPUNKNOWN* a1)
{
    _PrintEnter("CoCreateFreeThreadedMarshaler(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoCreateFreeThreadedMarshaler(a0, a1);
    } __finally {
        _PrintExit("CoCreateFreeThreadedMarshaler(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoCreateGuid(GUID* a0)
{
    _PrintEnter("CoCreateGuid(%lx)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_CoCreateGuid(a0);
    } __finally {
        _PrintExit("CoCreateGuid() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoCreateInstance(IID& a0,
                                        LPUNKNOWN a1,
                                        DWORD a2,
                                        IID& a3,
                                        LPVOID* a4)
{
    _PrintEnter("CoCreateInstance(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    HRESULT rv = 0;
    __try {
        rv = Real_CoCreateInstance(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CoCreateInstance(,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoCreateInstanceEx(IID& a0,
                                          IUnknown* a1,
                                          DWORD a2,
                                          COSERVERINFO* a3,
                                          DWORD a4,
                                          struct tagMULTI_QI* a5)
{
    _PrintEnter("CoCreateInstanceEx(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    HRESULT rv = 0;
    __try {
        rv = Real_CoCreateInstanceEx(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CoCreateInstanceEx(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoDisconnectObject(LPUNKNOWN a0,
                                          DWORD a1)
{
    _PrintEnter("CoDisconnectObject(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoDisconnectObject(a0, a1);
    } __finally {
        _PrintExit("CoDisconnectObject(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CoDosDateTimeToFileTime(WORD a0,
                                            WORD a1,
                                            FILETIME* a2)
{
    _PrintEnter("CoDosDateTimeToFileTime(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_CoDosDateTimeToFileTime(a0, a1, a2);
    } __finally {
        _PrintExit("CoDosDateTimeToFileTime(,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoFileTimeNow(FILETIME* a0)
{
    _PrintEnter("CoFileTimeNow(%lx)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_CoFileTimeNow(a0);
    } __finally {
        _PrintExit("CoFileTimeNow() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CoFileTimeToDosDateTime(FILETIME* a0,
                                            LPWORD a1,
                                            LPWORD a2)
{
    _PrintEnter("CoFileTimeToDosDateTime(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_CoFileTimeToDosDateTime(a0, a1, a2);
    } __finally {
        _PrintExit("CoFileTimeToDosDateTime(,,) -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_CoFreeAllLibraries(void)
{
    _PrintEnter("CoFreeAllLibraries()\n");

    __try {
        Real_CoFreeAllLibraries();
    } __finally {
        _PrintExit("CoFreeAllLibraries() ->\n");
    };
}

void __stdcall Mine_CoFreeLibrary(HINSTANCE a0)
{
    _PrintEnter("CoFreeLibrary(%lx)\n", a0);

    __try {
        Real_CoFreeLibrary(a0);
    } __finally {
        _PrintExit("CoFreeLibrary() ->\n");
    };
}

void __stdcall Mine_CoFreeUnusedLibraries(void)
{
    _PrintEnter("CoFreeUnusedLibraries()\n");

    __try {
        Real_CoFreeUnusedLibraries();
    } __finally {
        _PrintExit("CoFreeUnusedLibraries() ->\n");
    };
}

HRESULT __stdcall Mine_CoGetCallContext(IID& a0,
                                        void** a1)
{
    _PrintEnter("CoGetCallContext(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoGetCallContext(a0, a1);
    } __finally {
        _PrintExit("CoGetCallContext(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoGetClassObject(IID& a0,
                                        DWORD a1,
                                        LPVOID a2,
                                        IID& a3,
                                        LPVOID* a4)
{
    _PrintEnter("CoGetClassObject(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    HRESULT rv = 0;
    __try {
        rv = Real_CoGetClassObject(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CoGetClassObject(,,,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_CoGetCurrentProcess(void)
{
    _PrintEnter("CoGetCurrentProcess()\n");

    DWORD rv = 0;
    __try {
        rv = Real_CoGetCurrentProcess();
    } __finally {
        _PrintExit("CoGetCurrentProcess() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoGetInstanceFromFile(COSERVERINFO* a0,
                                             CLSID* a1,
                                             IUnknown* a2,
                                             DWORD a3,
                                             DWORD a4,
                                             OLECHAR* a5,
                                             DWORD a6,
                                             struct tagMULTI_QI* a7)
{
    _PrintEnter("CoGetInstanceFromFile(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    HRESULT rv = 0;
    __try {
        rv = Real_CoGetInstanceFromFile(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("CoGetInstanceFromFile(,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoGetInstanceFromIStorage(COSERVERINFO* a0,
                                                 CLSID* a1,
                                                 IUnknown* a2,
                                                 DWORD a3,
                                                 IStorage* a4,
                                                 DWORD a5,
                                                 struct tagMULTI_QI* a6)
{
    _PrintEnter("CoGetInstanceFromIStorage(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    HRESULT rv = 0;
    __try {
        rv = Real_CoGetInstanceFromIStorage(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("CoGetInstanceFromIStorage(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoGetInterfaceAndReleaseStream(LPSTREAM a0,
                                                      IID& a1,
                                                      LPVOID* a2)
{
    _PrintEnter("CoGetInterfaceAndReleaseStream(%lx,%lx,%lx)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_CoGetInterfaceAndReleaseStream(a0, a1, a2);
    } __finally {
        _PrintExit("CoGetInterfaceAndReleaseStream(,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoGetMalloc(DWORD a0,
                                   struct IMalloc** a1)
{
    _PrintEnter("CoGetMalloc(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoGetMalloc(a0, a1);
    } __finally {
        _PrintExit("CoGetMalloc(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoGetMarshalSizeMax(ULONG* a0,
                                           IID& a1,
                                           LPUNKNOWN a2,
                                           DWORD a3,
                                           LPVOID a4,
                                           DWORD a5)
{
    _PrintEnter("CoGetMarshalSizeMax(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    HRESULT rv = 0;
    __try {
        rv = Real_CoGetMarshalSizeMax(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CoGetMarshalSizeMax(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoGetObject(LPCWSTR a0,
                                   BIND_OPTS* a1,
                                   IID& a2,
                                   void** a3)
{
    _PrintEnter("CoGetObject(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_CoGetObject(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CoGetObject(,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoGetPSClsid(IID& a0,
                                    CLSID* a1)
{
    _PrintEnter("CoGetPSClsid(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoGetPSClsid(a0, a1);
    } __finally {
        _PrintExit("CoGetPSClsid(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoGetStandardMarshal(IID& a0,
                                            LPUNKNOWN a1,
                                            DWORD a2,
                                            LPVOID a3,
                                            DWORD a4,
                                            struct IMarshal** a5)
{
    _PrintEnter("CoGetStandardMarshal(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    HRESULT rv = 0;
    __try {
        rv = Real_CoGetStandardMarshal(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CoGetStandardMarshal(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoGetStdMarshalEx(LPUNKNOWN a0,
                                         DWORD a1,
                                         LPUNKNOWN* a2)
{
    _PrintEnter("CoGetStdMarshalEx(%lx,%lx,%lx)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_CoGetStdMarshalEx(a0, a1, a2);
    } __finally {
        _PrintExit("CoGetStdMarshalEx(,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoGetTreatAsClass(IID& a0,
                                         struct _GUID* a1)
{
    _PrintEnter("CoGetTreatAsClass(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoGetTreatAsClass(a0, a1);
    } __finally {
        _PrintExit("CoGetTreatAsClass(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoImpersonateClient(void)
{
    _PrintEnter("CoImpersonateClient()\n");

    HRESULT rv = 0;
    __try {
        rv = Real_CoImpersonateClient();
    } __finally {
        _PrintExit("CoImpersonateClient() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoInitialize(LPVOID a0)
{
    _PrintEnter("CoInitialize(%lx)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_CoInitialize(a0);
    } __finally {
        _PrintExit("CoInitialize() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoInitializeEx(LPVOID a0,
                                      DWORD a1)
{
    _PrintEnter("CoInitializeEx(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoInitializeEx(a0, a1);
    } __finally {
        _PrintExit("CoInitializeEx(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoInitializeSecurity(PSECURITY_DESCRIPTOR a0,
                                            LONG a1,
                                            struct tagSOLE_AUTHENTICATION_SERVICE* a2,
                                            void* a3,
                                            DWORD a4,
                                            DWORD a5,
                                            void* a6,
                                            DWORD a7,
                                            void* a8)
{
    _PrintEnter("CoInitializeSecurity(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8);

    HRESULT rv = 0;
    __try {
        rv = Real_CoInitializeSecurity(a0, a1, a2, a3, a4, a5, a6, a7, a8);
    } __finally {
        _PrintExit("CoInitializeSecurity(,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoInstall(IBindCtx* a0,
                                 DWORD a1,
                                 uCLSSPEC* a2,
                                 struct tagQUERYCONTEXT* a3,
                                 LPWSTR a4)
{
    _PrintEnter("CoInstall(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    HRESULT rv = 0;
    __try {
        rv = Real_CoInstall(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CoInstall(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CoIsHandlerConnected(LPUNKNOWN a0)
{
    _PrintEnter("CoIsHandlerConnected(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_CoIsHandlerConnected(a0);
    } __finally {
        _PrintExit("CoIsHandlerConnected() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CoIsOle1Class(IID& a0)
{
    _PrintEnter("CoIsOle1Class(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_CoIsOle1Class(a0);
    } __finally {
        _PrintExit("CoIsOle1Class() -> %lx\n", rv);
    };
    return rv;
}

HINSTANCE __stdcall Mine_CoLoadLibrary(LPOLESTR a0,
                                       BOOL a1)
{
    _PrintEnter("CoLoadLibrary(%lx,%lx)\n", a0, a1);

    HINSTANCE rv = 0;
    __try {
        rv = Real_CoLoadLibrary(a0, a1);
    } __finally {
        _PrintExit("CoLoadLibrary(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoLockObjectExternal(LPUNKNOWN a0,
                                            BOOL a1,
                                            BOOL a2)
{
    _PrintEnter("CoLockObjectExternal(%lx,%lx,%lx)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_CoLockObjectExternal(a0, a1, a2);
    } __finally {
        _PrintExit("CoLockObjectExternal(,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoMarshalHresult(LPSTREAM a0,
                                        HRESULT a1)
{
    _PrintEnter("CoMarshalHresult(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoMarshalHresult(a0, a1);
    } __finally {
        _PrintExit("CoMarshalHresult(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoMarshalInterThreadInterfaceInStream(IID& a0,
                                                             LPUNKNOWN a1,
                                                             LPSTREAM* a2)
{
    _PrintEnter("CoMarshalInterThreadInterfaceInStream(%lx,%lx,%lx)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_CoMarshalInterThreadInterfaceInStream(a0, a1, a2);
    } __finally {
        _PrintExit("CoMarshalInterThreadInterfaceInStream(,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoMarshalInterface(LPSTREAM a0,
                                          IID& a1,
                                          LPUNKNOWN a2,
                                          DWORD a3,
                                          LPVOID a4,
                                          DWORD a5)
{
    _PrintEnter("CoMarshalInterface(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    HRESULT rv = 0;
    __try {
        rv = Real_CoMarshalInterface(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CoMarshalInterface(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoQueryAuthenticationServices(DWORD* a0,
                                                     struct tagSOLE_AUTHENTICATION_SERVICE** a1)
{
    _PrintEnter("CoQueryAuthenticationServices(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoQueryAuthenticationServices(a0, a1);
    } __finally {
        _PrintExit("CoQueryAuthenticationServices(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoQueryClientBlanket(DWORD* a0,
                                            DWORD* a1,
                                            OLECHAR** a2,
                                            DWORD* a3,
                                            DWORD* a4,
                                            RPC_AUTHZ_HANDLE* a5,
                                            DWORD* a6)
{
    _PrintEnter("CoQueryClientBlanket(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    HRESULT rv = 0;
    __try {
        rv = Real_CoQueryClientBlanket(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("CoQueryClientBlanket(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoQueryProxyBlanket(IUnknown* a0,
                                           DWORD* a1,
                                           DWORD* a2,
                                           OLECHAR** a3,
                                           DWORD* a4,
                                           DWORD* a5,
                                           RPC_AUTH_IDENTITY_HANDLE* a6,
                                           DWORD* a7)
{
    _PrintEnter("CoQueryProxyBlanket(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    HRESULT rv = 0;
    __try {
        rv = Real_CoQueryProxyBlanket(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("CoQueryProxyBlanket(,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoRegisterChannelHook(GUID& a0,
                                             IChannelHook* a1)
{
    _PrintEnter("CoRegisterChannelHook(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoRegisterChannelHook(a0, a1);
    } __finally {
        _PrintExit("CoRegisterChannelHook(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoRegisterClassObject(IID& a0,
                                             LPUNKNOWN a1,
                                             DWORD a2,
                                             DWORD a3,
                                             LPDWORD a4)
{
    _PrintEnter("CoRegisterClassObject(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    HRESULT rv = 0;
    __try {
        rv = Real_CoRegisterClassObject(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CoRegisterClassObject(,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoRegisterMallocSpy(struct IMallocSpy* a0)
{
    _PrintEnter("CoRegisterMallocSpy(%lx)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_CoRegisterMallocSpy(a0);
    } __finally {
        _PrintExit("CoRegisterMallocSpy() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoRegisterMessageFilter(LPMESSAGEFILTER a0,
                                               LPMESSAGEFILTER* a1)
{
    _PrintEnter("CoRegisterMessageFilter(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoRegisterMessageFilter(a0, a1);
    } __finally {
        _PrintExit("CoRegisterMessageFilter(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoRegisterPSClsid(IID& a0,
                                         IID& a1)
{
    _PrintEnter("CoRegisterPSClsid(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoRegisterPSClsid(a0, a1);
    } __finally {
        _PrintExit("CoRegisterPSClsid(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoRegisterSurrogate(LPSURROGATE a0)
{
    _PrintEnter("CoRegisterSurrogate(%lx)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_CoRegisterSurrogate(a0);
    } __finally {
        _PrintExit("CoRegisterSurrogate() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoReleaseMarshalData(LPSTREAM a0)
{
    _PrintEnter("CoReleaseMarshalData(%lx)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_CoReleaseMarshalData(a0);
    } __finally {
        _PrintExit("CoReleaseMarshalData() -> %lx\n", rv);
    };
    return rv;
}

ULONG __stdcall Mine_CoReleaseServerProcess(void)
{
    _PrintEnter("CoReleaseServerProcess()\n");

    ULONG rv = 0;
    __try {
        rv = Real_CoReleaseServerProcess();
    } __finally {
        _PrintExit("CoReleaseServerProcess() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoResumeClassObjects(void)
{
    _PrintEnter("CoResumeClassObjects()\n");

    HRESULT rv = 0;
    __try {
        rv = Real_CoResumeClassObjects();
    } __finally {
        _PrintExit("CoResumeClassObjects() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoRevertToSelf(void)
{
    _PrintEnter("CoRevertToSelf()\n");

    HRESULT rv = 0;
    __try {
        rv = Real_CoRevertToSelf();
    } __finally {
        _PrintExit("CoRevertToSelf() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoRevokeClassObject(DWORD a0)
{
    _PrintEnter("CoRevokeClassObject(%lx)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_CoRevokeClassObject(a0);
    } __finally {
        _PrintExit("CoRevokeClassObject() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoRevokeMallocSpy(void)
{
    _PrintEnter("CoRevokeMallocSpy()\n");

    HRESULT rv = 0;
    __try {
        rv = Real_CoRevokeMallocSpy();
    } __finally {
        _PrintExit("CoRevokeMallocSpy() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoSetProxyBlanket(IUnknown* a0,
                                         DWORD a1,
                                         DWORD a2,
                                         OLECHAR* a3,
                                         DWORD a4,
                                         DWORD a5,
                                         RPC_AUTH_IDENTITY_HANDLE a6,
                                         DWORD a7)
{
    _PrintEnter("CoSetProxyBlanket(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    HRESULT rv = 0;
    __try {
        rv = Real_CoSetProxyBlanket(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("CoSetProxyBlanket(,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoSuspendClassObjects(void)
{
    _PrintEnter("CoSuspendClassObjects()\n");

    HRESULT rv = 0;
    __try {
        rv = Real_CoSuspendClassObjects();
    } __finally {
        _PrintExit("CoSuspendClassObjects() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoSwitchCallContext(IUnknown* a0,
                                           IUnknown** a1)
{
    _PrintEnter("CoSwitchCallContext(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoSwitchCallContext(a0, a1);
    } __finally {
        _PrintExit("CoSwitchCallContext(,) -> %lx\n", rv);
    };
    return rv;
}

LPVOID __stdcall Mine_CoTaskMemAlloc(ULONG a0)
{
    _PrintEnter("CoTaskMemAlloc(%lx)\n", a0);

    LPVOID rv = 0;
    __try {
        rv = Real_CoTaskMemAlloc(a0);
    } __finally {
        _PrintExit("CoTaskMemAlloc() -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_CoTaskMemFree(LPVOID a0)
{
    _PrintEnter("CoTaskMemFree(%lx)\n", a0);

    __try {
        Real_CoTaskMemFree(a0);
    } __finally {
        _PrintExit("CoTaskMemFree() ->\n");
    };
}

LPVOID __stdcall Mine_CoTaskMemRealloc(LPVOID a0,
                                       ULONG a1)
{
    _PrintEnter("CoTaskMemRealloc(%lx,%lx)\n", a0, a1);

    LPVOID rv = 0;
    __try {
        rv = Real_CoTaskMemRealloc(a0, a1);
    } __finally {
        _PrintExit("CoTaskMemRealloc(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoTreatAsClass(IID& a0,
                                      IID& a1)
{
    _PrintEnter("CoTreatAsClass(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoTreatAsClass(a0, a1);
    } __finally {
        _PrintExit("CoTreatAsClass(,) -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_CoUninitialize(void)
{
    _PrintEnter("CoUninitialize()\n");

    __try {
        Real_CoUninitialize();
    } __finally {
        _PrintExit("CoUninitialize() ->\n");
    };
}

HRESULT __stdcall Mine_CoUnmarshalHresult(LPSTREAM a0,
                                          HRESULT* a1)
{
    _PrintEnter("CoUnmarshalHresult(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CoUnmarshalHresult(a0, a1);
    } __finally {
        _PrintExit("CoUnmarshalHresult(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CoUnmarshalInterface(LPSTREAM a0,
                                            IID& a1,
                                            LPVOID* a2)
{
    _PrintEnter("CoUnmarshalInterface(%lx,%lx,%lx)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_CoUnmarshalInterface(a0, a1, a2);
    } __finally {
        _PrintExit("CoUnmarshalInterface(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ColorMatchToTarget(HDC a0,
                                       HDC a1,
                                       DWORD a2)
{
    _PrintEnter("ColorMatchToTarget(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_ColorMatchToTarget(a0, a1, a2);
    } __finally {
        _PrintExit("ColorMatchToTarget(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_CombineRgn(HRGN a0,
                              HRGN a1,
                              HRGN a2,
                              int a3)
{
    _PrintEnter("CombineRgn(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_CombineRgn(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CombineRgn(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CombineTransform(struct tagXFORM* a0,
                                     XFORM* a1,
                                     XFORM* a2)
{
    _PrintEnter("CombineTransform(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_CombineTransform(a0, a1, a2);
    } __finally {
        _PrintExit("CombineTransform(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CommConfigDialogA(LPCSTR a0,
                                      HWND a1,
                                      LPCOMMCONFIG a2)
{
    _PrintEnter("CommConfigDialogA(%hs,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_CommConfigDialogA(a0, a1, a2);
    } __finally {
        _PrintExit("CommConfigDialogA(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CommConfigDialogW(LPCWSTR a0,
                                      HWND a1,
                                      LPCOMMCONFIG a2)
{
    _PrintEnter("CommConfigDialogW(%ls,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_CommConfigDialogW(a0, a1, a2);
    } __finally {
        _PrintExit("CommConfigDialogW(,,) -> %lx\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_CompareFileTime(FILETIME* a0,
                                    FILETIME* a1)
{
    _PrintEnter("CompareFileTime(%lx,%lx)\n", a0, a1);

    LONG rv = 0;
    __try {
        rv = Real_CompareFileTime(a0, a1);
    } __finally {
        _PrintExit("CompareFileTime(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_CompareStringA(LCID a0,
                                  DWORD a1,
                                  LPCSTR a2,
                                  int a3,
                                  LPCSTR a4,
                                  int a5)
{
    _PrintEnter("CompareStringA(%lx,%lx,%hs,%lx,%hs,%lx)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_CompareStringA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CompareStringA(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_CompareStringW(LCID a0,
                                  DWORD a1,
                                  LPCWSTR a2,
                                  int a3,
                                  LPCWSTR a4,
                                  int a5)
{
    _PrintEnter("CompareStringW(%lx,%lx,%ls,%lx,%ls,%lx)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_CompareStringW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CompareStringW(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ConnectNamedPipe(HANDLE a0,
                                     LPOVERLAPPED a1)
{
    _PrintEnter("ConnectNamedPipe(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_ConnectNamedPipe(a0, a1);
    } __finally {
        _PrintExit("ConnectNamedPipe(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ContinueDebugEvent(DWORD a0,
                                       DWORD a1,
                                       DWORD a2)
{
    _PrintEnter("ContinueDebugEvent(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_ContinueDebugEvent(a0, a1, a2);
    } __finally {
        _PrintExit("ContinueDebugEvent(,,) -> %lx\n", rv);
    };
    return rv;
}

LCID __stdcall Mine_ConvertDefaultLocale(LCID a0)
{
    _PrintEnter("ConvertDefaultLocale(%lx)\n", a0);

    LCID rv = 0;
    __try {
        rv = Real_ConvertDefaultLocale(a0);
    } __finally {
        _PrintExit("ConvertDefaultLocale() -> %lx\n", rv);
    };
    return rv;
}

LPVOID __stdcall Mine_ConvertThreadToFiber(LPVOID a0)
{
    _PrintEnter("ConvertThreadToFiber(%lx)\n", a0);

    LPVOID rv = 0;
    __try {
        rv = Real_ConvertThreadToFiber(a0);
    } __finally {
        _PrintExit("ConvertThreadToFiber() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_CopyAcceleratorTableA(HACCEL a0,
                                         struct tagACCEL* a1,
                                         int a2)
{
    _PrintEnter("CopyAcceleratorTableA(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_CopyAcceleratorTableA(a0, a1, a2);
    } __finally {
        _PrintExit("CopyAcceleratorTableA(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_CopyAcceleratorTableW(HACCEL a0,
                                         struct tagACCEL* a1,
                                         int a2)
{
    _PrintEnter("CopyAcceleratorTableW(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_CopyAcceleratorTableW(a0, a1, a2);
    } __finally {
        _PrintExit("CopyAcceleratorTableW(,,) -> %lx\n", rv);
    };
    return rv;
}

HENHMETAFILE __stdcall Mine_CopyEnhMetaFileA(HENHMETAFILE a0,
                                             LPCSTR a1)
{
    _PrintEnter("CopyEnhMetaFileA(%lx,%hs)\n", a0, a1);

    HENHMETAFILE rv = 0;
    __try {
        rv = Real_CopyEnhMetaFileA(a0, a1);
    } __finally {
        _PrintExit("CopyEnhMetaFileA(,) -> %lx\n", rv);
    };
    return rv;
}

HENHMETAFILE __stdcall Mine_CopyEnhMetaFileW(HENHMETAFILE a0,
                                             LPCWSTR a1)
{
    _PrintEnter("CopyEnhMetaFileW(%lx,%ls)\n", a0, a1);

    HENHMETAFILE rv = 0;
    __try {
        rv = Real_CopyEnhMetaFileW(a0, a1);
    } __finally {
        _PrintExit("CopyEnhMetaFileW(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CopyFileA(LPCSTR a0,
                              LPCSTR a1,
                              BOOL a2)
{
    _PrintEnter("CopyFileA(%hs,%hs,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_CopyFileA(a0, a1, a2);
    } __finally {
        _PrintExit("CopyFileA(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CopyFileExA(LPCSTR a0,
                                LPCSTR a1,
                                LPPROGRESS_ROUTINE a2,
                                LPVOID a3,
                                LPBOOL a4,
                                DWORD a5)
{
    _PrintEnter("CopyFileExA(%hs,%hs,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_CopyFileExA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CopyFileExA(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CopyFileExW(LPCWSTR a0,
                                LPCWSTR a1,
                                LPPROGRESS_ROUTINE a2,
                                LPVOID a3,
                                LPBOOL a4,
                                DWORD a5)
{
    _PrintEnter("CopyFileExW(%ls,%ls,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_CopyFileExW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CopyFileExW(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CopyFileW(LPCWSTR a0,
                              LPCWSTR a1,
                              BOOL a2)
{
    _PrintEnter("CopyFileW(%ls,%ls,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_CopyFileW(a0, a1, a2);
    } __finally {
        _PrintExit("CopyFileW(,,) -> %lx\n", rv);
    };
    return rv;
}

HICON __stdcall Mine_CopyIcon(HICON a0)
{
    _PrintEnter("CopyIcon(%lx)\n", a0);

    HICON rv = 0;
    __try {
        rv = Real_CopyIcon(a0);
    } __finally {
        _PrintExit("CopyIcon() -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CopyImage(HANDLE a0,
                                UINT a1,
                                int a2,
                                int a3,
                                UINT a4)
{
    _PrintEnter("CopyImage(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    HANDLE rv = 0;
    __try {
        rv = Real_CopyImage(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CopyImage(,,,,) -> %lx\n", rv);
    };
    return rv;
}

HMETAFILE __stdcall Mine_CopyMetaFileA(HMETAFILE a0,
                                       LPCSTR a1)
{
    _PrintEnter("CopyMetaFileA(%lx,%hs)\n", a0, a1);

    HMETAFILE rv = 0;
    __try {
        rv = Real_CopyMetaFileA(a0, a1);
    } __finally {
        _PrintExit("CopyMetaFileA(,) -> %lx\n", rv);
    };
    return rv;
}

HMETAFILE __stdcall Mine_CopyMetaFileW(HMETAFILE a0,
                                       LPCWSTR a1)
{
    _PrintEnter("CopyMetaFileW(%lx,%ls)\n", a0, a1);

    HMETAFILE rv = 0;
    __try {
        rv = Real_CopyMetaFileW(a0, a1);
    } __finally {
        _PrintExit("CopyMetaFileW(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CopyRect(LPRECT a0,
                             RECT* a1)
{
    _PrintEnter("CopyRect(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_CopyRect(a0, a1);
    } __finally {
        _PrintExit("CopyRect(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_CountClipboardFormats(void)
{
    _PrintEnter("CountClipboardFormats()\n");

    int rv = 0;
    __try {
        rv = Real_CountClipboardFormats();
    } __finally {
        _PrintExit("CountClipboardFormats() -> %lx\n", rv);
    };
    return rv;
}

HACCEL __stdcall Mine_CreateAcceleratorTableA(struct tagACCEL* a0,
                                              int a1)
{
    _PrintEnter("CreateAcceleratorTableA(%lx,%lx)\n", a0, a1);

    HACCEL rv = 0;
    __try {
        rv = Real_CreateAcceleratorTableA(a0, a1);
    } __finally {
        _PrintExit("CreateAcceleratorTableA(,) -> %lx\n", rv);
    };
    return rv;
}

HACCEL __stdcall Mine_CreateAcceleratorTableW(struct tagACCEL* a0,
                                              int a1)
{
    _PrintEnter("CreateAcceleratorTableW(%lx,%lx)\n", a0, a1);

    HACCEL rv = 0;
    __try {
        rv = Real_CreateAcceleratorTableW(a0, a1);
    } __finally {
        _PrintExit("CreateAcceleratorTableW(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreateAntiMoniker(struct IMoniker** a0)
{
    _PrintEnter("CreateAntiMoniker(%lx)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_CreateAntiMoniker(a0);
    } __finally {
        _PrintExit("CreateAntiMoniker() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreateBindCtx(DWORD a0,
                                     struct IBindCtx** a1)
{
    _PrintEnter("CreateBindCtx(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CreateBindCtx(a0, a1);
    } __finally {
        _PrintExit("CreateBindCtx(,) -> %lx\n", rv);
    };
    return rv;
}

HBITMAP __stdcall Mine_CreateBitmap(int a0,
                                    int a1,
                                    UINT a2,
                                    UINT a3,
                                    void* a4)
{
    _PrintEnter("CreateBitmap(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    HBITMAP rv = 0;
    __try {
        rv = Real_CreateBitmap(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CreateBitmap(,,,,) -> %lx\n", rv);
    };
    return rv;
}

HBITMAP __stdcall Mine_CreateBitmapIndirect(BITMAP* a0)
{
    _PrintEnter("CreateBitmapIndirect(%lx)\n", a0);

    HBITMAP rv = 0;
    __try {
        rv = Real_CreateBitmapIndirect(a0);
    } __finally {
        _PrintExit("CreateBitmapIndirect() -> %lx\n", rv);
    };
    return rv;
}

HBRUSH __stdcall Mine_CreateBrushIndirect(struct tagLOGBRUSH* a0)
{
    _PrintEnter("CreateBrushIndirect(%lx)\n", a0);

    HBRUSH rv = 0;
    __try {
        rv = Real_CreateBrushIndirect(a0);
    } __finally {
        _PrintExit("CreateBrushIndirect() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CreateCaret(HWND a0,
                                HBITMAP a1,
                                int a2,
                                int a3)
{
    _PrintEnter("CreateCaret(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_CreateCaret(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateCaret(,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreateClassMoniker(IID& a0,
                                          struct IMoniker** a1)
{
    _PrintEnter("CreateClassMoniker(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CreateClassMoniker(a0, a1);
    } __finally {
        _PrintExit("CreateClassMoniker(,) -> %lx\n", rv);
    };
    return rv;
}

HCOLORSPACE __stdcall Mine_CreateColorSpaceA(struct tagLOGCOLORSPACEA* a0)
{
    _PrintEnter("CreateColorSpaceA(%lx)\n", a0);

    HCOLORSPACE rv = 0;
    __try {
        rv = Real_CreateColorSpaceA(a0);
    } __finally {
        _PrintExit("CreateColorSpaceA() -> %lx\n", rv);
    };
    return rv;
}

HCOLORSPACE __stdcall Mine_CreateColorSpaceW(struct tagLOGCOLORSPACEW* a0)
{
    _PrintEnter("CreateColorSpaceW(%lx)\n", a0);

    HCOLORSPACE rv = 0;
    __try {
        rv = Real_CreateColorSpaceW(a0);
    } __finally {
        _PrintExit("CreateColorSpaceW() -> %lx\n", rv);
    };
    return rv;
}

HBITMAP __stdcall Mine_CreateCompatibleBitmap(HDC a0,
                                              int a1,
                                              int a2)
{
    _PrintEnter("CreateCompatibleBitmap(%lx,%lx,%lx)\n", a0, a1, a2);

    HBITMAP rv = 0;
    __try {
        rv = Real_CreateCompatibleBitmap(a0, a1, a2);
    } __finally {
        _PrintExit("CreateCompatibleBitmap(,,) -> %lx\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_CreateCompatibleDC(HDC a0)
{
    _PrintEnter("CreateCompatibleDC(%lx)\n", a0);

    HDC rv = 0;
    __try {
        rv = Real_CreateCompatibleDC(a0);
    } __finally {
        _PrintExit("CreateCompatibleDC() -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateConsoleScreenBuffer(DWORD a0,
                                                DWORD a1,
                                                SECURITY_ATTRIBUTES* a2,
                                                DWORD a3,
                                                LPVOID a4)
{
    _PrintEnter("CreateConsoleScreenBuffer(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateConsoleScreenBuffer(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CreateConsoleScreenBuffer(,,,,) -> %lx\n", rv);
    };
    return rv;
}

HCURSOR __stdcall Mine_CreateCursor(HINSTANCE a0,
                                    int a1,
                                    int a2,
                                    int a3,
                                    int a4,
                                    void* a5,
                                    void* a6)
{
    _PrintEnter("CreateCursor(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    HCURSOR rv = 0;
    __try {
        rv = Real_CreateCursor(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("CreateCursor(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_CreateDCA(LPCSTR a0,
                             LPCSTR a1,
                             LPCSTR a2,
                             struct _devicemodeA* a3)
{
    _PrintEnter("CreateDCA(%hs,%hs,%hs,%lx)\n", a0, a1, a2, a3);

    HDC rv = 0;
    __try {
        rv = Real_CreateDCA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateDCA(,,,) -> %lx\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_CreateDCW(LPCWSTR a0,
                             LPCWSTR a1,
                             LPCWSTR a2,
                             struct _devicemodeW* a3)
{
    _PrintEnter("CreateDCW(%ls,%ls,%ls,%lx)\n", a0, a1, a2, a3);

    HDC rv = 0;
    __try {
        rv = Real_CreateDCW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateDCW(,,,) -> %lx\n", rv);
    };
    return rv;
}

HBRUSH __stdcall Mine_CreateDIBPatternBrush(HGLOBAL a0,
                                            UINT a1)
{
    _PrintEnter("CreateDIBPatternBrush(%lx,%lx)\n", a0, a1);

    HBRUSH rv = 0;
    __try {
        rv = Real_CreateDIBPatternBrush(a0, a1);
    } __finally {
        _PrintExit("CreateDIBPatternBrush(,) -> %lx\n", rv);
    };
    return rv;
}

HBRUSH __stdcall Mine_CreateDIBPatternBrushPt(void* a0,
                                              UINT a1)
{
    _PrintEnter("CreateDIBPatternBrushPt(%lx,%lx)\n", a0, a1);

    HBRUSH rv = 0;
    __try {
        rv = Real_CreateDIBPatternBrushPt(a0, a1);
    } __finally {
        _PrintExit("CreateDIBPatternBrushPt(,) -> %lx\n", rv);
    };
    return rv;
}

HBITMAP __stdcall Mine_CreateDIBSection(HDC a0,
                                        struct tagBITMAPINFO* a1,
                                        UINT a2,
                                        void** a3,
                                        HANDLE a4,
                                        DWORD a5)
{
    _PrintEnter("CreateDIBSection(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    HBITMAP rv = 0;
    __try {
        rv = Real_CreateDIBSection(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CreateDIBSection(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HBITMAP __stdcall Mine_CreateDIBitmap(HDC a0,
                                      BITMAPINFOHEADER* a1,
                                      DWORD a2,
                                      void* a3,
                                      struct tagBITMAPINFO* a4,
                                      UINT a5)
{
    _PrintEnter("CreateDIBitmap(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    HBITMAP rv = 0;
    __try {
        rv = Real_CreateDIBitmap(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CreateDIBitmap(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreateDataAdviseHolder(LPDATAADVISEHOLDER* a0)
{
    _PrintEnter("CreateDataAdviseHolder(%lx)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_CreateDataAdviseHolder(a0);
    } __finally {
        _PrintExit("CreateDataAdviseHolder() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreateDataCache(LPUNKNOWN a0,
                                       IID& a1,
                                       IID& a2,
                                       LPVOID* a3)
{
    _PrintEnter("CreateDataCache(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_CreateDataCache(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateDataCache(,,,) -> %lx\n", rv);
    };
    return rv;
}

HDESK __stdcall Mine_CreateDesktopA(LPCSTR a0,
                                    LPCSTR a1,
                                    LPDEVMODEA a2,
                                    DWORD a3,
                                    ACCESS_MASK a4,
                                    LPSECURITY_ATTRIBUTES a5)
{
    _PrintEnter("CreateDesktopA(%hs,%hs,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    HDESK rv = 0;
    __try {
        rv = Real_CreateDesktopA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CreateDesktopA(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HDESK __stdcall Mine_CreateDesktopW(LPCWSTR a0,
                                    LPCWSTR a1,
                                    LPDEVMODEW a2,
                                    DWORD a3,
                                    ACCESS_MASK a4,
                                    LPSECURITY_ATTRIBUTES a5)
{
    _PrintEnter("CreateDesktopW(%ls,%ls,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    HDESK rv = 0;
    __try {
        rv = Real_CreateDesktopW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CreateDesktopW(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_CreateDialogIndirectParamA(HINSTANCE a0,
                                               LPCDLGTEMPLATEA a1,
                                               HWND a2,
                                               DLGPROC a3,
                                               LPARAM a4)
{
    _PrintEnter("CreateDialogIndirectParamA(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    HWND rv = 0;
    __try {
        rv = Real_CreateDialogIndirectParamA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CreateDialogIndirectParamA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_CreateDialogIndirectParamW(HINSTANCE a0,
                                               LPCDLGTEMPLATEW a1,
                                               HWND a2,
                                               DLGPROC a3,
                                               LPARAM a4)
{
    _PrintEnter("CreateDialogIndirectParamW(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    HWND rv = 0;
    __try {
        rv = Real_CreateDialogIndirectParamW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CreateDialogIndirectParamW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_CreateDialogParamA(HINSTANCE a0,
                                       LPCSTR a1,
                                       HWND a2,
                                       DLGPROC a3,
                                       LPARAM a4)
{
    _PrintEnter("CreateDialogParamA(%lx,%hs,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    HWND rv = 0;
    __try {
        rv = Real_CreateDialogParamA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CreateDialogParamA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_CreateDialogParamW(HINSTANCE a0,
                                       LPCWSTR a1,
                                       HWND a2,
                                       DLGPROC a3,
                                       LPARAM a4)
{
    _PrintEnter("CreateDialogParamW(%lx,%ls,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    HWND rv = 0;
    __try {
        rv = Real_CreateDialogParamW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("CreateDialogParamW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CreateDirectoryA(LPCSTR a0,
                                     LPSECURITY_ATTRIBUTES a1)
{
    _PrintEnter("CreateDirectoryA(%hs,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_CreateDirectoryA(a0, a1);
    } __finally {
        _PrintExit("CreateDirectoryA(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CreateDirectoryExA(LPCSTR a0,
                                       LPCSTR a1,
                                       LPSECURITY_ATTRIBUTES a2)
{
    _PrintEnter("CreateDirectoryExA(%hs,%hs,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_CreateDirectoryExA(a0, a1, a2);
    } __finally {
        _PrintExit("CreateDirectoryExA(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CreateDirectoryExW(LPCWSTR a0,
                                       LPCWSTR a1,
                                       LPSECURITY_ATTRIBUTES a2)
{
    _PrintEnter("CreateDirectoryExW(%ls,%ls,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_CreateDirectoryExW(a0, a1, a2);
    } __finally {
        _PrintExit("CreateDirectoryExW(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CreateDirectoryW(LPCWSTR a0,
                                     LPSECURITY_ATTRIBUTES a1)
{
    _PrintEnter("CreateDirectoryW(%ls,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_CreateDirectoryW(a0, a1);
    } __finally {
        _PrintExit("CreateDirectoryW(,) -> %lx\n", rv);
    };
    return rv;
}

HBITMAP __stdcall Mine_CreateDiscardableBitmap(HDC a0,
                                               int a1,
                                               int a2)
{
    _PrintEnter("CreateDiscardableBitmap(%lx,%lx,%lx)\n", a0, a1, a2);

    HBITMAP rv = 0;
    __try {
        rv = Real_CreateDiscardableBitmap(a0, a1, a2);
    } __finally {
        _PrintExit("CreateDiscardableBitmap(,,) -> %lx\n", rv);
    };
    return rv;
}

HRGN __stdcall Mine_CreateEllipticRgn(int a0,
                                      int a1,
                                      int a2,
                                      int a3)
{
    _PrintEnter("CreateEllipticRgn(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HRGN rv = 0;
    __try {
        rv = Real_CreateEllipticRgn(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateEllipticRgn(,,,) -> %lx\n", rv);
    };
    return rv;
}

HRGN __stdcall Mine_CreateEllipticRgnIndirect(RECT* a0)
{
    _PrintEnter("CreateEllipticRgnIndirect(%lx)\n", a0);

    HRGN rv = 0;
    __try {
        rv = Real_CreateEllipticRgnIndirect(a0);
    } __finally {
        _PrintExit("CreateEllipticRgnIndirect() -> %lx\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_CreateEnhMetaFileA(HDC a0,
                                      LPCSTR a1,
                                      RECT* a2,
                                      LPCSTR a3)
{
    _PrintEnter("CreateEnhMetaFileA(%lx,%hs,%lx,%hs)\n", a0, a1, a2, a3);

    HDC rv = 0;
    __try {
        rv = Real_CreateEnhMetaFileA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateEnhMetaFileA(,,,) -> %lx\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_CreateEnhMetaFileW(HDC a0,
                                      LPCWSTR a1,
                                      RECT* a2,
                                      LPCWSTR a3)
{
    _PrintEnter("CreateEnhMetaFileW(%lx,%ls,%lx,%ls)\n", a0, a1, a2, a3);

    HDC rv = 0;
    __try {
        rv = Real_CreateEnhMetaFileW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateEnhMetaFileW(,,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateEventA(LPSECURITY_ATTRIBUTES a0,
                                   BOOL a1,
                                   BOOL a2,
                                   LPCSTR a3)
{
    _PrintEnter("CreateEventA(%lx,%lx,%lx,%hs)\n", a0, a1, a2, a3);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateEventA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateEventA(,,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateEventW(LPSECURITY_ATTRIBUTES a0,
                                   BOOL a1,
                                   BOOL a2,
                                   LPCWSTR a3)
{
    _PrintEnter("CreateEventW(%lx,%lx,%lx,%ls)\n", a0, a1, a2, a3);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateEventW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateEventW(,,,) -> %lx\n", rv);
    };
    return rv;
}

LPVOID __stdcall Mine_CreateFiber(DWORD a0,
                                  LPFIBER_START_ROUTINE a1,
                                  LPVOID a2)
{
    _PrintEnter("CreateFiber(%lx,%lx,%lx)\n", a0, a1, a2);

    LPVOID rv = 0;
    __try {
        rv = Real_CreateFiber(a0, a1, a2);
    } __finally {
        _PrintExit("CreateFiber(,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateFileA(LPCSTR a0,
                                  DWORD a1,
                                  DWORD a2,
                                  LPSECURITY_ATTRIBUTES a3,
                                  DWORD a4,
                                  DWORD a5,
                                  HANDLE a6)
{
    _PrintEnter("CreateFileA(%hs,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateFileA(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("CreateFileA(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateFileMappingA(HANDLE a0,
                                         LPSECURITY_ATTRIBUTES a1,
                                         DWORD a2,
                                         DWORD a3,
                                         DWORD a4,
                                         LPCSTR a5)
{
    _PrintEnter("CreateFileMappingA(%lx,%lx,%lx,%lx,%lx,%hs)\n", a0, a1, a2, a3, a4, a5);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateFileMappingA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CreateFileMappingA(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateFileMappingW(HANDLE a0,
                                         LPSECURITY_ATTRIBUTES a1,
                                         DWORD a2,
                                         DWORD a3,
                                         DWORD a4,
                                         LPCWSTR a5)
{
    _PrintEnter("CreateFileMappingW(%lx,%lx,%lx,%lx,%lx,%ls)\n", a0, a1, a2, a3, a4, a5);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateFileMappingW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CreateFileMappingW(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreateFileMoniker(LPCOLESTR a0,
                                         struct IMoniker** a1)
{
    _PrintEnter("CreateFileMoniker(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CreateFileMoniker(a0, a1);
    } __finally {
        _PrintExit("CreateFileMoniker(,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateFileW(LPCWSTR a0,
                                  DWORD a1,
                                  DWORD a2,
                                  LPSECURITY_ATTRIBUTES a3,
                                  DWORD a4,
                                  DWORD a5,
                                  HANDLE a6)
{
    _PrintEnter("CreateFileW(%ls,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateFileW(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("CreateFileW(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HFONT __stdcall Mine_CreateFontA(int a0,
                                 int a1,
                                 int a2,
                                 int a3,
                                 int a4,
                                 DWORD a5,
                                 DWORD a6,
                                 DWORD a7,
                                 DWORD a8,
                                 DWORD a9,
                                 DWORD a10,
                                 DWORD a11,
                                 DWORD a12,
                                 LPCSTR a13)
{
    _PrintEnter("CreateFontA(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%hs)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);

    HFONT rv = 0;
    __try {
        rv = Real_CreateFontA(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
    } __finally {
        _PrintExit("CreateFontA(,,,,,,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HFONT __stdcall Mine_CreateFontIndirectA(LOGFONTA* a0)
{
    _PrintEnter("CreateFontIndirectA(%lx)\n", a0);

    HFONT rv = 0;
    __try {
        rv = Real_CreateFontIndirectA(a0);
    } __finally {
        _PrintExit("CreateFontIndirectA() -> %lx\n", rv);
    };
    return rv;
}

HFONT __stdcall Mine_CreateFontIndirectW(LOGFONTW* a0)
{
    _PrintEnter("CreateFontIndirectW(%lx)\n", a0);

    HFONT rv = 0;
    __try {
        rv = Real_CreateFontIndirectW(a0);
    } __finally {
        _PrintExit("CreateFontIndirectW() -> %lx\n", rv);
    };
    return rv;
}

HFONT __stdcall Mine_CreateFontW(int a0,
                                 int a1,
                                 int a2,
                                 int a3,
                                 int a4,
                                 DWORD a5,
                                 DWORD a6,
                                 DWORD a7,
                                 DWORD a8,
                                 DWORD a9,
                                 DWORD a10,
                                 DWORD a11,
                                 DWORD a12,
                                 LPCWSTR a13)
{
    _PrintEnter("CreateFontW(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%ls)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);

    HFONT rv = 0;
    __try {
        rv = Real_CreateFontW(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
    } __finally {
        _PrintExit("CreateFontW(,,,,,,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreateGenericComposite(struct IMoniker* a0,
                                              struct IMoniker* a1,
                                              struct IMoniker** a2)
{
    _PrintEnter("CreateGenericComposite(%lx,%lx,%lx)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_CreateGenericComposite(a0, a1, a2);
    } __finally {
        _PrintExit("CreateGenericComposite(,,) -> %lx\n", rv);
    };
    return rv;
}

HPALETTE __stdcall Mine_CreateHalftonePalette(HDC a0)
{
    _PrintEnter("CreateHalftonePalette(%lx)\n", a0);

    HPALETTE rv = 0;
    __try {
        rv = Real_CreateHalftonePalette(a0);
    } __finally {
        _PrintExit("CreateHalftonePalette() -> %lx\n", rv);
    };
    return rv;
}

HBRUSH __stdcall Mine_CreateHatchBrush(int a0,
                                       COLORREF a1)
{
    _PrintEnter("CreateHatchBrush(%lx,%lx)\n", a0, a1);

    HBRUSH rv = 0;
    __try {
        rv = Real_CreateHatchBrush(a0, a1);
    } __finally {
        _PrintExit("CreateHatchBrush(,) -> %lx\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_CreateICA(LPCSTR a0,
                             LPCSTR a1,
                             LPCSTR a2,
                             struct _devicemodeA* a3)
{
    _PrintEnter("CreateICA(%hs,%hs,%hs,%lx)\n", a0, a1, a2, a3);

    HDC rv = 0;
    __try {
        rv = Real_CreateICA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateICA(,,,) -> %lx\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_CreateICW(LPCWSTR a0,
                             LPCWSTR a1,
                             LPCWSTR a2,
                             struct _devicemodeW* a3)
{
    _PrintEnter("CreateICW(%ls,%ls,%ls,%lx)\n", a0, a1, a2, a3);

    HDC rv = 0;
    __try {
        rv = Real_CreateICW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateICW(,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreateILockBytesOnHGlobal(HGLOBAL a0,
                                                 BOOL a1,
                                                 struct ILockBytes** a2)
{
    _PrintEnter("CreateILockBytesOnHGlobal(%lx,%lx,%lx)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_CreateILockBytesOnHGlobal(a0, a1, a2);
    } __finally {
        _PrintExit("CreateILockBytesOnHGlobal(,,) -> %lx\n", rv);
    };
    return rv;
}

HICON __stdcall Mine_CreateIcon(HINSTANCE a0,
                                int a1,
                                int a2,
                                BYTE a3,
                                BYTE a4,
                                BYTE* a5,
                                BYTE* a6)
{
    _PrintEnter("CreateIcon(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    HICON rv = 0;
    __try {
        rv = Real_CreateIcon(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("CreateIcon(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HICON __stdcall Mine_CreateIconFromResource(PBYTE a0,
                                            DWORD a1,
                                            BOOL a2,
                                            DWORD a3)
{
    _PrintEnter("CreateIconFromResource(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HICON rv = 0;
    __try {
        rv = Real_CreateIconFromResource(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateIconFromResource(,,,) -> %lx\n", rv);
    };
    return rv;
}

HICON __stdcall Mine_CreateIconFromResourceEx(PBYTE a0,
                                              DWORD a1,
                                              BOOL a2,
                                              DWORD a3,
                                              int a4,
                                              int a5,
                                              UINT a6)
{
    _PrintEnter("CreateIconFromResourceEx(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    HICON rv = 0;
    __try {
        rv = Real_CreateIconFromResourceEx(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("CreateIconFromResourceEx(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HICON __stdcall Mine_CreateIconIndirect(struct _ICONINFO* a0)
{
    _PrintEnter("CreateIconIndirect(%lx)\n", a0);

    HICON rv = 0;
    __try {
        rv = Real_CreateIconIndirect(a0);
    } __finally {
        _PrintExit("CreateIconIndirect() -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateIoCompletionPort(HANDLE a0,
                                             HANDLE a1,
                                             ULONG_PTR a2,
                                             DWORD a3)
{
    _PrintEnter("CreateIoCompletionPort(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateIoCompletionPort(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateIoCompletionPort(,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreateItemMoniker(LPCOLESTR a0,
                                         LPCOLESTR a1,
                                         struct IMoniker** a2)
{
    _PrintEnter("CreateItemMoniker(%lx,%lx,%lx)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_CreateItemMoniker(a0, a1, a2);
    } __finally {
        _PrintExit("CreateItemMoniker(,,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_CreateMDIWindowA(LPCSTR a0,
                                     LPCSTR a1,
                                     DWORD a2,
                                     int a3,
                                     int a4,
                                     int a5,
                                     int a6,
                                     HWND a7,
                                     HINSTANCE a8,
                                     LPARAM a9)
{
    _PrintEnter("CreateMDIWindowA(%hs,%hs,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);

    HWND rv = 0;
    __try {
        rv = Real_CreateMDIWindowA(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
    } __finally {
        _PrintExit("CreateMDIWindowA(,,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_CreateMDIWindowW(LPCWSTR a0,
                                     LPCWSTR a1,
                                     DWORD a2,
                                     int a3,
                                     int a4,
                                     int a5,
                                     int a6,
                                     HWND a7,
                                     HINSTANCE a8,
                                     LPARAM a9)
{
    _PrintEnter("CreateMDIWindowW(%ls,%ls,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);

    HWND rv = 0;
    __try {
        rv = Real_CreateMDIWindowW(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
    } __finally {
        _PrintExit("CreateMDIWindowW(,,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateMailslotA(LPCSTR a0,
                                      DWORD a1,
                                      DWORD a2,
                                      LPSECURITY_ATTRIBUTES a3)
{
    _PrintEnter("CreateMailslotA(%hs,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateMailslotA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateMailslotA(,,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateMailslotW(LPCWSTR a0,
                                      DWORD a1,
                                      DWORD a2,
                                      LPSECURITY_ATTRIBUTES a3)
{
    _PrintEnter("CreateMailslotW(%ls,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateMailslotW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateMailslotW(,,,) -> %lx\n", rv);
    };
    return rv;
}

HMENU __stdcall Mine_CreateMenu(void)
{
    _PrintEnter("CreateMenu()\n");

    HMENU rv = 0;
    __try {
        rv = Real_CreateMenu();
    } __finally {
        _PrintExit("CreateMenu() -> %lx\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_CreateMetaFileA(LPCSTR a0)
{
    _PrintEnter("CreateMetaFileA(%hs)\n", a0);

    HDC rv = 0;
    __try {
        rv = Real_CreateMetaFileA(a0);
    } __finally {
        _PrintExit("CreateMetaFileA() -> %lx\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_CreateMetaFileW(LPCWSTR a0)
{
    _PrintEnter("CreateMetaFileW(%ls)\n", a0);

    HDC rv = 0;
    __try {
        rv = Real_CreateMetaFileW(a0);
    } __finally {
        _PrintExit("CreateMetaFileW() -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateMutexA(LPSECURITY_ATTRIBUTES a0,
                                   BOOL a1,
                                   LPCSTR a2)
{
    _PrintEnter("CreateMutexA(%lx,%lx,%hs)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateMutexA(a0, a1, a2);
    } __finally {
        _PrintExit("CreateMutexA(,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateMutexW(LPSECURITY_ATTRIBUTES a0,
                                   BOOL a1,
                                   LPCWSTR a2)
{
    _PrintEnter("CreateMutexW(%lx,%lx,%ls)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateMutexW(a0, a1, a2);
    } __finally {
        _PrintExit("CreateMutexW(,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateNamedPipeA(LPCSTR a0,
                                       DWORD a1,
                                       DWORD a2,
                                       DWORD a3,
                                       DWORD a4,
                                       DWORD a5,
                                       DWORD a6,
                                       LPSECURITY_ATTRIBUTES a7)
{
    _PrintEnter("CreateNamedPipeA(%hs,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateNamedPipeA(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("CreateNamedPipeA(,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateNamedPipeW(LPCWSTR a0,
                                       DWORD a1,
                                       DWORD a2,
                                       DWORD a3,
                                       DWORD a4,
                                       DWORD a5,
                                       DWORD a6,
                                       LPSECURITY_ATTRIBUTES a7)
{
    _PrintEnter("CreateNamedPipeW(%ls,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateNamedPipeW(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("CreateNamedPipeW(,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreateOleAdviseHolder(LPOLEADVISEHOLDER* a0)
{
    _PrintEnter("CreateOleAdviseHolder(%lx)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_CreateOleAdviseHolder(a0);
    } __finally {
        _PrintExit("CreateOleAdviseHolder() -> %lx\n", rv);
    };
    return rv;
}

HPALETTE __stdcall Mine_CreatePalette(LOGPALETTE* a0)
{
    _PrintEnter("CreatePalette(%lx)\n", a0);

    HPALETTE rv = 0;
    __try {
        rv = Real_CreatePalette(a0);
    } __finally {
        _PrintExit("CreatePalette() -> %lx\n", rv);
    };
    return rv;
}

HBRUSH __stdcall Mine_CreatePatternBrush(HBITMAP a0)
{
    _PrintEnter("CreatePatternBrush(%lx)\n", a0);

    HBRUSH rv = 0;
    __try {
        rv = Real_CreatePatternBrush(a0);
    } __finally {
        _PrintExit("CreatePatternBrush() -> %lx\n", rv);
    };
    return rv;
}

HPEN __stdcall Mine_CreatePen(int a0,
                              int a1,
                              COLORREF a2)
{
    _PrintEnter("CreatePen(%lx,%lx,%lx)\n", a0, a1, a2);

    HPEN rv = 0;
    __try {
        rv = Real_CreatePen(a0, a1, a2);
    } __finally {
        _PrintExit("CreatePen(,,) -> %lx\n", rv);
    };
    return rv;
}

HPEN __stdcall Mine_CreatePenIndirect(LOGPEN* a0)
{
    _PrintEnter("CreatePenIndirect(%lx)\n", a0);

    HPEN rv = 0;
    __try {
        rv = Real_CreatePenIndirect(a0);
    } __finally {
        _PrintExit("CreatePenIndirect() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CreatePipe(PHANDLE a0,
                               PHANDLE a1,
                               LPSECURITY_ATTRIBUTES a2,
                               DWORD a3)
{
    _PrintEnter("CreatePipe(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_CreatePipe(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreatePipe(,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreatePointerMoniker(LPUNKNOWN a0,
                                            struct IMoniker** a1)
{
    _PrintEnter("CreatePointerMoniker(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_CreatePointerMoniker(a0, a1);
    } __finally {
        _PrintExit("CreatePointerMoniker(,) -> %lx\n", rv);
    };
    return rv;
}

HRGN __stdcall Mine_CreatePolyPolygonRgn(POINT* a0,
                                         INT* a1,
                                         int a2,
                                         int a3)
{
    _PrintEnter("CreatePolyPolygonRgn(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HRGN rv = 0;
    __try {
        rv = Real_CreatePolyPolygonRgn(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreatePolyPolygonRgn(,,,) -> %lx\n", rv);
    };
    return rv;
}

HRGN __stdcall Mine_CreatePolygonRgn(POINT* a0,
                                     int a1,
                                     int a2)
{
    _PrintEnter("CreatePolygonRgn(%lx,%lx,%lx)\n", a0, a1, a2);

    HRGN rv = 0;
    __try {
        rv = Real_CreatePolygonRgn(a0, a1, a2);
    } __finally {
        _PrintExit("CreatePolygonRgn(,,) -> %lx\n", rv);
    };
    return rv;
}

HMENU __stdcall Mine_CreatePopupMenu(void)
{
    _PrintEnter("CreatePopupMenu()\n");

    HMENU rv = 0;
    __try {
        rv = Real_CreatePopupMenu();
    } __finally {
        _PrintExit("CreatePopupMenu() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CreateProcessA(LPCSTR a0,
                                   LPSTR a1,
                                   LPSECURITY_ATTRIBUTES a2,
                                   LPSECURITY_ATTRIBUTES a3,
                                   BOOL a4,
                                   DWORD a5,
                                   LPVOID a6,
                                   LPCSTR a7,
                                   struct _STARTUPINFOA* a8,
                                   LPPROCESS_INFORMATION a9)
{
    _PrintEnter("CreateProcessA(%hs,%hs,%lx,%lx,%lx,%lx,%lx,%hs,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);

    BOOL rv = 0;
    __try {
        rv = Real_CreateProcessA(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
    } __finally {
        _PrintExit("CreateProcessA(,,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CreateProcessW(LPCWSTR a0,
                                   LPWSTR a1,
                                   LPSECURITY_ATTRIBUTES a2,
                                   LPSECURITY_ATTRIBUTES a3,
                                   BOOL a4,
                                   DWORD a5,
                                   LPVOID a6,
                                   LPCWSTR a7,
                                   struct _STARTUPINFOW* a8,
                                   LPPROCESS_INFORMATION a9)
{
    _PrintEnter("CreateProcessW(%ls,%ls,%lx,%lx,%lx,%lx,%lx,%ls,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);

    BOOL rv = 0;
    __try {
        rv = Real_CreateProcessW(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
    } __finally {
        _PrintExit("CreateProcessW(,,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRGN __stdcall Mine_CreateRectRgn(int a0,
                                  int a1,
                                  int a2,
                                  int a3)
{
    _PrintEnter("CreateRectRgn(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HRGN rv = 0;
    __try {
        rv = Real_CreateRectRgn(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateRectRgn(,,,) -> %lx\n", rv);
    };
    return rv;
}

HRGN __stdcall Mine_CreateRectRgnIndirect(RECT* a0)
{
    _PrintEnter("CreateRectRgnIndirect(%lx)\n", a0);

    HRGN rv = 0;
    __try {
        rv = Real_CreateRectRgnIndirect(a0);
    } __finally {
        _PrintExit("CreateRectRgnIndirect() -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateRemoteThread(HANDLE a0,
                                         LPSECURITY_ATTRIBUTES a1,
                                         DWORD a2,
                                         LPTHREAD_START_ROUTINE a3,
                                         LPVOID a4,
                                         DWORD a5,
                                         LPDWORD a6)
{
    _PrintEnter("CreateRemoteThread(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateRemoteThread(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("CreateRemoteThread(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRGN __stdcall Mine_CreateRoundRectRgn(int a0,
                                       int a1,
                                       int a2,
                                       int a3,
                                       int a4,
                                       int a5)
{
    _PrintEnter("CreateRoundRectRgn(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    HRGN rv = 0;
    __try {
        rv = Real_CreateRoundRectRgn(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CreateRoundRectRgn(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CreateScalableFontResourceA(DWORD a0,
                                                LPCSTR a1,
                                                LPCSTR a2,
                                                LPCSTR a3)
{
    _PrintEnter("CreateScalableFontResourceA(%lx,%hs,%hs,%hs)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_CreateScalableFontResourceA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateScalableFontResourceA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_CreateScalableFontResourceW(DWORD a0,
                                                LPCWSTR a1,
                                                LPCWSTR a2,
                                                LPCWSTR a3)
{
    _PrintEnter("CreateScalableFontResourceW(%lx,%ls,%ls,%ls)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_CreateScalableFontResourceW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateScalableFontResourceW(,,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateSemaphoreA(LPSECURITY_ATTRIBUTES a0,
                                       LONG a1,
                                       LONG a2,
                                       LPCSTR a3)
{
    _PrintEnter("CreateSemaphoreA(%lx,%lx,%lx,%hs)\n", a0, a1, a2, a3);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateSemaphoreA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateSemaphoreA(,,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateSemaphoreW(LPSECURITY_ATTRIBUTES a0,
                                       LONG a1,
                                       LONG a2,
                                       LPCWSTR a3)
{
    _PrintEnter("CreateSemaphoreW(%lx,%lx,%lx,%ls)\n", a0, a1, a2, a3);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateSemaphoreW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateSemaphoreW(,,,) -> %lx\n", rv);
    };
    return rv;
}

HBRUSH __stdcall Mine_CreateSolidBrush(COLORREF a0)
{
    _PrintEnter("CreateSolidBrush(%lx)\n", a0);

    HBRUSH rv = 0;
    __try {
        rv = Real_CreateSolidBrush(a0);
    } __finally {
        _PrintExit("CreateSolidBrush() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreateStdProgressIndicator(HWND a0,
                                                  LPCOLESTR a1,
                                                  IBindStatusCallback* a2,
                                                  IBindStatusCallback** a3)
{
    _PrintEnter("CreateStdProgressIndicator(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_CreateStdProgressIndicator(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateStdProgressIndicator(,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_CreateStreamOnHGlobal(HGLOBAL a0,
                                             BOOL a1,
                                             LPSTREAM* a2)
{
    _PrintEnter("CreateStreamOnHGlobal(%lx,%lx,%lx)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_CreateStreamOnHGlobal(a0, a1, a2);
    } __finally {
        _PrintExit("CreateStreamOnHGlobal(,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_CreateTapePartition(HANDLE a0,
                                         DWORD a1,
                                         DWORD a2,
                                         DWORD a3)
{
    _PrintEnter("CreateTapePartition(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    DWORD rv = 0;
    __try {
        rv = Real_CreateTapePartition(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateTapePartition(,,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateThread(LPSECURITY_ATTRIBUTES a0,
                                   DWORD a1,
                                   LPTHREAD_START_ROUTINE a2,
                                   LPVOID a3,
                                   DWORD a4,
                                   LPDWORD a5)
{
    _PrintEnter("CreateThread(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateThread(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("CreateThread(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateWaitableTimerA(LPSECURITY_ATTRIBUTES a0,
                                           BOOL a1,
                                           LPCSTR a2)
{
    _PrintEnter("CreateWaitableTimerA(%lx,%lx,%hs)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateWaitableTimerA(a0, a1, a2);
    } __finally {
        _PrintExit("CreateWaitableTimerA(,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_CreateWaitableTimerW(LPSECURITY_ATTRIBUTES a0,
                                           BOOL a1,
                                           LPCWSTR a2)
{
    _PrintEnter("CreateWaitableTimerW(%lx,%lx,%ls)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_CreateWaitableTimerW(a0, a1, a2);
    } __finally {
        _PrintExit("CreateWaitableTimerW(,,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_CreateWindowExA(DWORD a0,
                                    LPCSTR a1,
                                    LPCSTR a2,
                                    DWORD a3,
                                    int a4,
                                    int a5,
                                    int a6,
                                    int a7,
                                    HWND a8,
                                    HMENU a9,
                                    HINSTANCE a10,
                                    LPVOID a11)
{
    _PrintEnter("CreateWindowExA(%lx,%hs,%hs,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);

    HWND rv = 0;
    __try {
        rv = Real_CreateWindowExA(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
    } __finally {
        _PrintExit("CreateWindowExA(,,,,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_CreateWindowExW(DWORD a0,
                                    LPCWSTR a1,
                                    LPCWSTR a2,
                                    DWORD a3,
                                    int a4,
                                    int a5,
                                    int a6,
                                    int a7,
                                    HWND a8,
                                    HMENU a9,
                                    HINSTANCE a10,
                                    LPVOID a11)
{
    _PrintEnter("CreateWindowExW(%lx,%ls,%ls,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);

    HWND rv = 0;
    __try {
        rv = Real_CreateWindowExW(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
    } __finally {
        _PrintExit("CreateWindowExW(,,,,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HWINSTA __stdcall Mine_CreateWindowStationA(LPCSTR a0,
                                            DWORD a1,
                                            ACCESS_MASK a2,
                                            LPSECURITY_ATTRIBUTES a3)
{
    _PrintEnter("CreateWindowStationA(%hs,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HWINSTA rv = 0;
    __try {
        rv = Real_CreateWindowStationA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateWindowStationA(,,,) -> %lx\n", rv);
    };
    return rv;
}

HWINSTA __stdcall Mine_CreateWindowStationW(LPCWSTR a0,
                                            DWORD a1,
                                            ACCESS_MASK a2,
                                            LPSECURITY_ATTRIBUTES a3)
{
    _PrintEnter("CreateWindowStationW(%ls,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HWINSTA rv = 0;
    __try {
        rv = Real_CreateWindowStationW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("CreateWindowStationW(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DPtoLP(HDC a0,
                           struct tagPOINT* a1,
                           int a2)
{
    _PrintEnter("DPtoLP(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_DPtoLP(a0, a1, a2);
    } __finally {
        _PrintExit("DPtoLP(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdeAbandonTransaction(DWORD a0,
                                          HCONV a1,
                                          DWORD a2)
{
    _PrintEnter("DdeAbandonTransaction(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_DdeAbandonTransaction(a0, a1, a2);
    } __finally {
        _PrintExit("DdeAbandonTransaction(,,) -> %lx\n", rv);
    };
    return rv;
}

LPBYTE __stdcall Mine_DdeAccessData(HDDEDATA a0,
                                    LPDWORD a1)
{
    _PrintEnter("DdeAccessData(%lx,%lx)\n", a0, a1);

    LPBYTE rv = 0;
    __try {
        rv = Real_DdeAccessData(a0, a1);
    } __finally {
        _PrintExit("DdeAccessData(,) -> %lx\n", rv);
    };
    return rv;
}

HDDEDATA __stdcall Mine_DdeAddData(HDDEDATA a0,
                                   LPBYTE a1,
                                   DWORD a2,
                                   DWORD a3)
{
    _PrintEnter("DdeAddData(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HDDEDATA rv = 0;
    __try {
        rv = Real_DdeAddData(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DdeAddData(,,,) -> %lx\n", rv);
    };
    return rv;
}

HDDEDATA __stdcall Mine_DdeClientTransaction(LPBYTE a0,
                                             DWORD a1,
                                             HCONV a2,
                                             HSZ a3,
                                             UINT a4,
                                             UINT a5,
                                             DWORD a6,
                                             LPDWORD a7)
{
    _PrintEnter("DdeClientTransaction(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    HDDEDATA rv = 0;
    __try {
        rv = Real_DdeClientTransaction(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("DdeClientTransaction(,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_DdeCmpStringHandles(HSZ a0,
                                       HSZ a1)
{
    _PrintEnter("DdeCmpStringHandles(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_DdeCmpStringHandles(a0, a1);
    } __finally {
        _PrintExit("DdeCmpStringHandles(,) -> %lx\n", rv);
    };
    return rv;
}

HCONV __stdcall Mine_DdeConnect(DWORD a0,
                                HSZ a1,
                                HSZ a2,
                                PCONVCONTEXT a3)
{
    _PrintEnter("DdeConnect(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HCONV rv = 0;
    __try {
        rv = Real_DdeConnect(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DdeConnect(,,,) -> %lx\n", rv);
    };
    return rv;
}

HCONVLIST __stdcall Mine_DdeConnectList(DWORD a0,
                                        HSZ a1,
                                        HSZ a2,
                                        HCONVLIST a3,
                                        PCONVCONTEXT a4)
{
    _PrintEnter("DdeConnectList(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    HCONVLIST rv = 0;
    __try {
        rv = Real_DdeConnectList(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DdeConnectList(,,,,) -> %lx\n", rv);
    };
    return rv;
}

HDDEDATA __stdcall Mine_DdeCreateDataHandle(DWORD a0,
                                            LPBYTE a1,
                                            DWORD a2,
                                            DWORD a3,
                                            HSZ a4,
                                            UINT a5,
                                            UINT a6)
{
    _PrintEnter("DdeCreateDataHandle(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    HDDEDATA rv = 0;
    __try {
        rv = Real_DdeCreateDataHandle(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("DdeCreateDataHandle(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HSZ __stdcall Mine_DdeCreateStringHandleA(DWORD a0,
                                          LPCSTR a1,
                                          int a2)
{
    _PrintEnter("DdeCreateStringHandleA(%lx,%hs,%lx)\n", a0, a1, a2);

    HSZ rv = 0;
    __try {
        rv = Real_DdeCreateStringHandleA(a0, a1, a2);
    } __finally {
        _PrintExit("DdeCreateStringHandleA(,,) -> %lx\n", rv);
    };
    return rv;
}

HSZ __stdcall Mine_DdeCreateStringHandleW(DWORD a0,
                                          LPCWSTR a1,
                                          int a2)
{
    _PrintEnter("DdeCreateStringHandleW(%lx,%ls,%lx)\n", a0, a1, a2);

    HSZ rv = 0;
    __try {
        rv = Real_DdeCreateStringHandleW(a0, a1, a2);
    } __finally {
        _PrintExit("DdeCreateStringHandleW(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdeDisconnect(HCONV a0)
{
    _PrintEnter("DdeDisconnect(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DdeDisconnect(a0);
    } __finally {
        _PrintExit("DdeDisconnect() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdeDisconnectList(HCONVLIST a0)
{
    _PrintEnter("DdeDisconnectList(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DdeDisconnectList(a0);
    } __finally {
        _PrintExit("DdeDisconnectList() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdeEnableCallback(DWORD a0,
                                      HCONV a1,
                                      UINT a2)
{
    _PrintEnter("DdeEnableCallback(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_DdeEnableCallback(a0, a1, a2);
    } __finally {
        _PrintExit("DdeEnableCallback(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdeFreeDataHandle(HDDEDATA a0)
{
    _PrintEnter("DdeFreeDataHandle(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DdeFreeDataHandle(a0);
    } __finally {
        _PrintExit("DdeFreeDataHandle() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdeFreeStringHandle(DWORD a0,
                                        HSZ a1)
{
    _PrintEnter("DdeFreeStringHandle(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_DdeFreeStringHandle(a0, a1);
    } __finally {
        _PrintExit("DdeFreeStringHandle(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_DdeGetData(HDDEDATA a0,
                                LPBYTE a1,
                                DWORD a2,
                                DWORD a3)
{
    _PrintEnter("DdeGetData(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    DWORD rv = 0;
    __try {
        rv = Real_DdeGetData(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DdeGetData(,,,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_DdeGetLastError(DWORD a0)
{
    _PrintEnter("DdeGetLastError(%lx)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_DdeGetLastError(a0);
    } __finally {
        _PrintExit("DdeGetLastError() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdeImpersonateClient(HCONV a0)
{
    _PrintEnter("DdeImpersonateClient(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DdeImpersonateClient(a0);
    } __finally {
        _PrintExit("DdeImpersonateClient() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdeKeepStringHandle(DWORD a0,
                                        HSZ a1)
{
    _PrintEnter("DdeKeepStringHandle(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_DdeKeepStringHandle(a0, a1);
    } __finally {
        _PrintExit("DdeKeepStringHandle(,) -> %lx\n", rv);
    };
    return rv;
}

HDDEDATA __stdcall Mine_DdeNameService(DWORD a0,
                                       HSZ a1,
                                       HSZ a2,
                                       UINT a3)
{
    _PrintEnter("DdeNameService(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HDDEDATA rv = 0;
    __try {
        rv = Real_DdeNameService(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DdeNameService(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdePostAdvise(DWORD a0,
                                  HSZ a1,
                                  HSZ a2)
{
    _PrintEnter("DdePostAdvise(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_DdePostAdvise(a0, a1, a2);
    } __finally {
        _PrintExit("DdePostAdvise(,,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_DdeQueryConvInfo(HCONV a0,
                                     DWORD a1,
                                     struct tagCONVINFO* a2)
{
    _PrintEnter("DdeQueryConvInfo(%lx,%lx,%lx)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_DdeQueryConvInfo(a0, a1, a2);
    } __finally {
        _PrintExit("DdeQueryConvInfo(,,) -> %lx\n", rv);
    };
    return rv;
}

HCONV __stdcall Mine_DdeQueryNextServer(HCONVLIST a0,
                                        HCONV a1)
{
    _PrintEnter("DdeQueryNextServer(%lx,%lx)\n", a0, a1);

    HCONV rv = 0;
    __try {
        rv = Real_DdeQueryNextServer(a0, a1);
    } __finally {
        _PrintExit("DdeQueryNextServer(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_DdeQueryStringA(DWORD a0,
                                     HSZ a1,
                                     LPSTR a2,
                                     DWORD a3,
                                     int a4)
{
    _PrintEnter("DdeQueryStringA(%lx,%lx,%hs,%lx,%lx)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_DdeQueryStringA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DdeQueryStringA(,,%hs,,) -> %lx\n", a2, rv);
    };
    return rv;
}

DWORD __stdcall Mine_DdeQueryStringW(DWORD a0,
                                     HSZ a1,
                                     LPWSTR a2,
                                     DWORD a3,
                                     int a4)
{
    _PrintEnter("DdeQueryStringW(%lx,%lx,%ls,%lx,%lx)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_DdeQueryStringW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DdeQueryStringW(,,%ls,,) -> %lx\n", a2, rv);
    };
    return rv;
}

HCONV __stdcall Mine_DdeReconnect(HCONV a0)
{
    _PrintEnter("DdeReconnect(%lx)\n", a0);

    HCONV rv = 0;
    __try {
        rv = Real_DdeReconnect(a0);
    } __finally {
        _PrintExit("DdeReconnect() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdeSetQualityOfService(HWND a0,
                                           SECURITY_QUALITY_OF_SERVICE* a1,
                                           struct _SECURITY_QUALITY_OF_SERVICE* a2)
{
    _PrintEnter("DdeSetQualityOfService(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_DdeSetQualityOfService(a0, a1, a2);
    } __finally {
        _PrintExit("DdeSetQualityOfService(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdeSetUserHandle(HCONV a0,
                                     DWORD a1,
                                     DWORD a2)
{
    _PrintEnter("DdeSetUserHandle(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_DdeSetUserHandle(a0, a1, a2);
    } __finally {
        _PrintExit("DdeSetUserHandle(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdeUnaccessData(HDDEDATA a0)
{
    _PrintEnter("DdeUnaccessData(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DdeUnaccessData(a0);
    } __finally {
        _PrintExit("DdeUnaccessData() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DdeUninitialize(DWORD a0)
{
    _PrintEnter("DdeUninitialize(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DdeUninitialize(a0);
    } __finally {
        _PrintExit("DdeUninitialize() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DebugActiveProcess(DWORD a0)
{
    _PrintEnter("DebugActiveProcess(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DebugActiveProcess(a0);
    } __finally {
        _PrintExit("DebugActiveProcess() -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_DebugBreak(void)
{
    _PrintEnter("DebugBreak()\n");

    __try {
        Real_DebugBreak();
    } __finally {
        _PrintExit("DebugBreak() ->\n");
    };
}

LRESULT __stdcall Mine_DefDlgProcA(HWND a0,
                                   UINT a1,
                                   WPARAM a2,
                                   LPARAM a3)
{
    _PrintEnter("DefDlgProcA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    LRESULT rv = 0;
    __try {
        rv = Real_DefDlgProcA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DefDlgProcA(,,,) -> %lx\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_DefDlgProcW(HWND a0,
                                   UINT a1,
                                   WPARAM a2,
                                   LPARAM a3)
{
    _PrintEnter("DefDlgProcW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    LRESULT rv = 0;
    __try {
        rv = Real_DefDlgProcW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DefDlgProcW(,,,) -> %lx\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_DefFrameProcA(HWND a0,
                                     HWND a1,
                                     UINT a2,
                                     WPARAM a3,
                                     LPARAM a4)
{
    _PrintEnter("DefFrameProcA(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    LRESULT rv = 0;
    __try {
        rv = Real_DefFrameProcA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DefFrameProcA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_DefFrameProcW(HWND a0,
                                     HWND a1,
                                     UINT a2,
                                     WPARAM a3,
                                     LPARAM a4)
{
    _PrintEnter("DefFrameProcW(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    LRESULT rv = 0;
    __try {
        rv = Real_DefFrameProcW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DefFrameProcW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_DefMDIChildProcA(HWND a0,
                                        UINT a1,
                                        WPARAM a2,
                                        LPARAM a3)
{
    _PrintEnter("DefMDIChildProcA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    LRESULT rv = 0;
    __try {
        rv = Real_DefMDIChildProcA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DefMDIChildProcA(,,,) -> %lx\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_DefMDIChildProcW(HWND a0,
                                        UINT a1,
                                        WPARAM a2,
                                        LPARAM a3)
{
    _PrintEnter("DefMDIChildProcW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    LRESULT rv = 0;
    __try {
        rv = Real_DefMDIChildProcW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DefMDIChildProcW(,,,) -> %lx\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_DefWindowProcA(HWND a0,
                                      UINT a1,
                                      WPARAM a2,
                                      LPARAM a3)
{
    _PrintEnter("DefWindowProcA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    LRESULT rv = 0;
    __try {
        rv = Real_DefWindowProcA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DefWindowProcA(,,,) -> %lx\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_DefWindowProcW(HWND a0,
                                      UINT a1,
                                      WPARAM a2,
                                      LPARAM a3)
{
    _PrintEnter("DefWindowProcW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    LRESULT rv = 0;
    __try {
        rv = Real_DefWindowProcW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DefWindowProcW(,,,) -> %lx\n", rv);
    };
    return rv;
}

HDWP __stdcall Mine_DeferWindowPos(HDWP a0,
                                   HWND a1,
                                   HWND a2,
                                   int a3,
                                   int a4,
                                   int a5,
                                   int a6,
                                   UINT a7)
{
    _PrintEnter("DeferWindowPos(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    HDWP rv = 0;
    __try {
        rv = Real_DeferWindowPos(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("DeferWindowPos(,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DefineDosDeviceA(DWORD a0,
                                     LPCSTR a1,
                                     LPCSTR a2)
{
    _PrintEnter("DefineDosDeviceA(%lx,%hs,%hs)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_DefineDosDeviceA(a0, a1, a2);
    } __finally {
        _PrintExit("DefineDosDeviceA(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DefineDosDeviceW(DWORD a0,
                                     LPCWSTR a1,
                                     LPCWSTR a2)
{
    _PrintEnter("DefineDosDeviceW(%lx,%ls,%ls)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_DefineDosDeviceW(a0, a1, a2);
    } __finally {
        _PrintExit("DefineDosDeviceW(,,) -> %lx\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_DeleteAtom(ATOM a0)
{
    _PrintEnter("DeleteAtom(%lx)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_DeleteAtom(a0);
    } __finally {
        _PrintExit("DeleteAtom() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DeleteColorSpace(HCOLORSPACE a0)
{
    _PrintEnter("DeleteColorSpace(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DeleteColorSpace(a0);
    } __finally {
        _PrintExit("DeleteColorSpace() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DeleteDC(HDC a0)
{
    _PrintEnter("DeleteDC(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DeleteDC(a0);
    } __finally {
        _PrintExit("DeleteDC() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DeleteEnhMetaFile(HENHMETAFILE a0)
{
    _PrintEnter("DeleteEnhMetaFile(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DeleteEnhMetaFile(a0);
    } __finally {
        _PrintExit("DeleteEnhMetaFile() -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_DeleteFiber(LPVOID a0)
{
    _PrintEnter("DeleteFiber(%lx)\n", a0);

    __try {
        Real_DeleteFiber(a0);
    } __finally {
        _PrintExit("DeleteFiber() ->\n");
    };
}

BOOL __stdcall Mine_DeleteFileA(LPCSTR a0)
{
    _PrintEnter("DeleteFileA(%hs)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DeleteFileA(a0);
    } __finally {
        _PrintExit("DeleteFileA() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DeleteFileW(LPCWSTR a0)
{
    _PrintEnter("DeleteFileW(%ls)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DeleteFileW(a0);
    } __finally {
        _PrintExit("DeleteFileW() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DeleteMenu(HMENU a0,
                               UINT a1,
                               UINT a2)
{
    _PrintEnter("DeleteMenu(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_DeleteMenu(a0, a1, a2);
    } __finally {
        _PrintExit("DeleteMenu(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DeleteMetaFile(HMETAFILE a0)
{
    _PrintEnter("DeleteMetaFile(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DeleteMetaFile(a0);
    } __finally {
        _PrintExit("DeleteMetaFile() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DeleteObject(HGDIOBJ a0)
{
    _PrintEnter("DeleteObject(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DeleteObject(a0);
    } __finally {
        _PrintExit("DeleteObject() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_DescribePixelFormat(HDC a0,
                                       int a1,
                                       UINT a2,
                                       struct tagPIXELFORMATDESCRIPTOR* a3)
{
    _PrintEnter("DescribePixelFormat(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_DescribePixelFormat(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DescribePixelFormat(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DestroyAcceleratorTable(HACCEL a0)
{
    _PrintEnter("DestroyAcceleratorTable(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DestroyAcceleratorTable(a0);
    } __finally {
        _PrintExit("DestroyAcceleratorTable() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DestroyCaret(void)
{
    _PrintEnter("DestroyCaret()\n");

    BOOL rv = 0;
    __try {
        rv = Real_DestroyCaret();
    } __finally {
        _PrintExit("DestroyCaret() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DestroyCursor(HCURSOR a0)
{
    _PrintEnter("DestroyCursor(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DestroyCursor(a0);
    } __finally {
        _PrintExit("DestroyCursor() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DestroyIcon(HICON a0)
{
    _PrintEnter("DestroyIcon(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DestroyIcon(a0);
    } __finally {
        _PrintExit("DestroyIcon() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DestroyMenu(HMENU a0)
{
    _PrintEnter("DestroyMenu(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DestroyMenu(a0);
    } __finally {
        _PrintExit("DestroyMenu() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DestroyWindow(HWND a0)
{
    _PrintEnter("DestroyWindow(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DestroyWindow(a0);
    } __finally {
        _PrintExit("DestroyWindow() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DeviceIoControl(HANDLE a0,
                                    DWORD a1,
                                    LPVOID a2,
                                    DWORD a3,
                                    LPVOID a4,
                                    DWORD a5,
                                    LPDWORD a6,
                                    LPOVERLAPPED a7)
{
    _PrintEnter("DeviceIoControl(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    BOOL rv = 0;
    __try {
        rv = Real_DeviceIoControl(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("DeviceIoControl(,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

INT_PTR __stdcall Mine_DialogBoxIndirectParamA(HINSTANCE a0,
                                               LPCDLGTEMPLATEA a1,
                                               HWND a2,
                                               DLGPROC a3,
                                               LPARAM a4)
{
    _PrintEnter("DialogBoxIndirectParamA(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    INT_PTR rv = 0;
    __try {
        rv = Real_DialogBoxIndirectParamA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DialogBoxIndirectParamA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

INT_PTR __stdcall Mine_DialogBoxIndirectParamW(HINSTANCE a0,
                                               LPCDLGTEMPLATEW a1,
                                               HWND a2,
                                               DLGPROC a3,
                                               LPARAM a4)
{
    _PrintEnter("DialogBoxIndirectParamW(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    INT_PTR rv = 0;
    __try {
        rv = Real_DialogBoxIndirectParamW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DialogBoxIndirectParamW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

INT_PTR __stdcall Mine_DialogBoxParamA(HINSTANCE a0,
                                       LPCSTR a1,
                                       HWND a2,
                                       DLGPROC a3,
                                       LPARAM a4)
{
    _PrintEnter("DialogBoxParamA(%lx,%hs,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    INT_PTR rv = 0;
    __try {
        rv = Real_DialogBoxParamA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DialogBoxParamA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

INT_PTR __stdcall Mine_DialogBoxParamW(HINSTANCE a0,
                                       LPCWSTR a1,
                                       HWND a2,
                                       DLGPROC a3,
                                       LPARAM a4)
{
    _PrintEnter("DialogBoxParamW(%lx,%ls,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    INT_PTR rv = 0;
    __try {
        rv = Real_DialogBoxParamW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DialogBoxParamW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DisableThreadLibraryCalls(HMODULE a0)
{
    _PrintEnter("DisableThreadLibraryCalls(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DisableThreadLibraryCalls(a0);
    } __finally {
        _PrintExit("DisableThreadLibraryCalls() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DisconnectNamedPipe(HANDLE a0)
{
    _PrintEnter("DisconnectNamedPipe(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DisconnectNamedPipe(a0);
    } __finally {
        _PrintExit("DisconnectNamedPipe() -> %lx\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_DispatchMessageA(struct tagMSG* a0)
{
    _PrintEnter("DispatchMessageA(%lx)\n", a0);

    LRESULT rv = 0;
    __try {
        rv = Real_DispatchMessageA(a0);
    } __finally {
        _PrintExit("DispatchMessageA() -> %lx\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_DispatchMessageW(struct tagMSG* a0)
{
    _PrintEnter("DispatchMessageW(%lx)\n", a0);

    LRESULT rv = 0;
    __try {
        rv = Real_DispatchMessageW(a0);
    } __finally {
        _PrintExit("DispatchMessageW() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_DlgDirListA(HWND a0,
                               LPSTR a1,
                               int a2,
                               int a3,
                               UINT a4)
{
    _PrintEnter("DlgDirListA(%lx,%hs,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_DlgDirListA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DlgDirListA(,%hs,,,) -> %lx\n", a1, rv);
    };
    return rv;
}

int __stdcall Mine_DlgDirListComboBoxA(HWND a0,
                                       LPSTR a1,
                                       int a2,
                                       int a3,
                                       UINT a4)
{
    _PrintEnter("DlgDirListComboBoxA(%lx,%hs,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_DlgDirListComboBoxA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DlgDirListComboBoxA(,%hs,,,) -> %lx\n", a1, rv);
    };
    return rv;
}

int __stdcall Mine_DlgDirListComboBoxW(HWND a0,
                                       LPWSTR a1,
                                       int a2,
                                       int a3,
                                       UINT a4)
{
    _PrintEnter("DlgDirListComboBoxW(%lx,%ls,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_DlgDirListComboBoxW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DlgDirListComboBoxW(,%ls,,,) -> %lx\n", a1, rv);
    };
    return rv;
}

int __stdcall Mine_DlgDirListW(HWND a0,
                               LPWSTR a1,
                               int a2,
                               int a3,
                               UINT a4)
{
    _PrintEnter("DlgDirListW(%lx,%ls,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_DlgDirListW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DlgDirListW(,%ls,,,) -> %lx\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_DlgDirSelectComboBoxExA(HWND a0,
                                            LPSTR a1,
                                            int a2,
                                            int a3)
{
    _PrintEnter("DlgDirSelectComboBoxExA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_DlgDirSelectComboBoxExA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DlgDirSelectComboBoxExA(,%hs,,) -> %lx\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_DlgDirSelectComboBoxExW(HWND a0,
                                            LPWSTR a1,
                                            int a2,
                                            int a3)
{
    _PrintEnter("DlgDirSelectComboBoxExW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_DlgDirSelectComboBoxExW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DlgDirSelectComboBoxExW(,%ls,,) -> %lx\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_DlgDirSelectExA(HWND a0,
                                    LPSTR a1,
                                    int a2,
                                    int a3)
{
    _PrintEnter("DlgDirSelectExA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_DlgDirSelectExA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DlgDirSelectExA(,%hs,,) -> %lx\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_DlgDirSelectExW(HWND a0,
                                    LPWSTR a1,
                                    int a2,
                                    int a3)
{
    _PrintEnter("DlgDirSelectExW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_DlgDirSelectExW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DlgDirSelectExW(,%ls,,) -> %lx\n", a1, rv);
    };
    return rv;
}

HRESULT __stdcall Mine_DoDragDrop(struct IDataObject* a0,
                                  struct IDropSource* a1,
                                  DWORD a2,
                                  LPDWORD a3)
{
    _PrintEnter("DoDragDrop(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_DoDragDrop(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DoDragDrop(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DosDateTimeToFileTime(WORD a0,
                                          WORD a1,
                                          LPFILETIME a2)
{
    _PrintEnter("DosDateTimeToFileTime(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_DosDateTimeToFileTime(a0, a1, a2);
    } __finally {
        _PrintExit("DosDateTimeToFileTime(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DragDetect(HWND a0,
                               POINT a1)
{
    _PrintEnter("DragDetect(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_DragDetect(a0, a1);
    } __finally {
        _PrintExit("DragDetect(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_DragObject(HWND a0,
                                HWND a1,
                                UINT a2,
                                ULONG_PTR a3,
                                HCURSOR a4)
{
    _PrintEnter("DragObject(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_DragObject(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DragObject(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DrawAnimatedRects(HWND a0,
                                      int a1,
                                      RECT* a2,
                                      RECT* a3)
{
    _PrintEnter("DrawAnimatedRects(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_DrawAnimatedRects(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DrawAnimatedRects(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DrawCaption(HWND a0,
                                HDC a1,
                                RECT* a2,
                                UINT a3)
{
    _PrintEnter("DrawCaption(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_DrawCaption(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DrawCaption(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DrawEdge(HDC a0,
                             LPRECT a1,
                             UINT a2,
                             UINT a3)
{
    _PrintEnter("DrawEdge(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_DrawEdge(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DrawEdge(,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_DrawEscape(HDC a0,
                              int a1,
                              int a2,
                              LPCSTR a3)
{
    _PrintEnter("DrawEscape(%lx,%lx,%lx,%hs)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_DrawEscape(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DrawEscape(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DrawFocusRect(HDC a0,
                                  RECT* a1)
{
    _PrintEnter("DrawFocusRect(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_DrawFocusRect(a0, a1);
    } __finally {
        _PrintExit("DrawFocusRect(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DrawFrameControl(HDC a0,
                                     LPRECT a1,
                                     UINT a2,
                                     UINT a3)
{
    _PrintEnter("DrawFrameControl(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_DrawFrameControl(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DrawFrameControl(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DrawIcon(HDC a0,
                             int a1,
                             int a2,
                             HICON a3)
{
    _PrintEnter("DrawIcon(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_DrawIcon(a0, a1, a2, a3);
    } __finally {
        _PrintExit("DrawIcon(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DrawIconEx(HDC a0,
                               int a1,
                               int a2,
                               HICON a3,
                               int a4,
                               int a5,
                               UINT a6,
                               HBRUSH a7,
                               UINT a8)
{
    _PrintEnter("DrawIconEx(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8);

    BOOL rv = 0;
    __try {
        rv = Real_DrawIconEx(a0, a1, a2, a3, a4, a5, a6, a7, a8);
    } __finally {
        _PrintExit("DrawIconEx(,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DrawMenuBar(HWND a0)
{
    _PrintEnter("DrawMenuBar(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_DrawMenuBar(a0);
    } __finally {
        _PrintExit("DrawMenuBar() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DrawStateA(HDC a0,
                               HBRUSH a1,
                               DRAWSTATEPROC a2,
                               LPARAM a3,
                               WPARAM a4,
                               int a5,
                               int a6,
                               int a7,
                               int a8,
                               UINT a9)
{
    _PrintEnter("DrawStateA(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);

    BOOL rv = 0;
    __try {
        rv = Real_DrawStateA(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
    } __finally {
        _PrintExit("DrawStateA(,,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DrawStateW(HDC a0,
                               HBRUSH a1,
                               DRAWSTATEPROC a2,
                               LPARAM a3,
                               WPARAM a4,
                               int a5,
                               int a6,
                               int a7,
                               int a8,
                               UINT a9)
{
    _PrintEnter("DrawStateW(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);

    BOOL rv = 0;
    __try {
        rv = Real_DrawStateW(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
    } __finally {
        _PrintExit("DrawStateW(,,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_DrawTextA(HDC a0,
                             LPCSTR a1,
                             int a2,
                             LPRECT a3,
                             UINT a4)
{
    _PrintEnter("DrawTextA(%lx,%hs,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_DrawTextA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DrawTextA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_DrawTextExA(HDC a0,
                               LPSTR a1,
                               int a2,
                               LPRECT a3,
                               UINT a4,
                               LPDRAWTEXTPARAMS a5)
{
    _PrintEnter("DrawTextExA(%lx,%hs,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_DrawTextExA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("DrawTextExA(,%hs,,,,) -> %lx\n", a1, rv);
    };
    return rv;
}

int __stdcall Mine_DrawTextExW(HDC a0,
                               LPWSTR a1,
                               int a2,
                               LPRECT a3,
                               UINT a4,
                               LPDRAWTEXTPARAMS a5)
{
    _PrintEnter("DrawTextExW(%lx,%ls,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_DrawTextExW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("DrawTextExW(,%ls,,,,) -> %lx\n", a1, rv);
    };
    return rv;
}

int __stdcall Mine_DrawTextW(HDC a0,
                             LPCWSTR a1,
                             int a2,
                             LPRECT a3,
                             UINT a4)
{
    _PrintEnter("DrawTextW(%lx,%ls,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_DrawTextW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("DrawTextW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_DuplicateHandle(HANDLE a0,
                                    HANDLE a1,
                                    HANDLE a2,
                                    LPHANDLE a3,
                                    DWORD a4,
                                    BOOL a5,
                                    DWORD a6)
{
    _PrintEnter("DuplicateHandle(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_DuplicateHandle(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("DuplicateHandle(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_Ellipse(HDC a0,
                            int a1,
                            int a2,
                            int a3,
                            int a4)
{
    _PrintEnter("Ellipse(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_Ellipse(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("Ellipse(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EmptyClipboard(void)
{
    _PrintEnter("EmptyClipboard()\n");

    BOOL rv = 0;
    __try {
        rv = Real_EmptyClipboard();
    } __finally {
        _PrintExit("EmptyClipboard() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnableMenuItem(HMENU a0,
                                   UINT a1,
                                   UINT a2)
{
    _PrintEnter("EnableMenuItem(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnableMenuItem(a0, a1, a2);
    } __finally {
        _PrintExit("EnableMenuItem(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnableScrollBar(HWND a0,
                                    UINT a1,
                                    UINT a2)
{
    _PrintEnter("EnableScrollBar(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnableScrollBar(a0, a1, a2);
    } __finally {
        _PrintExit("EnableScrollBar(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnableWindow(HWND a0,
                                 BOOL a1)
{
    _PrintEnter("EnableWindow(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EnableWindow(a0, a1);
    } __finally {
        _PrintExit("EnableWindow(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EndDeferWindowPos(HDWP a0)
{
    _PrintEnter("EndDeferWindowPos(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_EndDeferWindowPos(a0);
    } __finally {
        _PrintExit("EndDeferWindowPos() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EndDialog(HWND a0,
                              INT_PTR a1)
{
    _PrintEnter("EndDialog(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EndDialog(a0, a1);
    } __finally {
        _PrintExit("EndDialog(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_EndDoc(HDC a0)
{
    _PrintEnter("EndDoc(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_EndDoc(a0);
    } __finally {
        _PrintExit("EndDoc() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_EndPage(HDC a0)
{
    _PrintEnter("EndPage(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_EndPage(a0);
    } __finally {
        _PrintExit("EndPage() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EndPaint(HWND a0,
                             PAINTSTRUCT* a1)
{
    _PrintEnter("EndPaint(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EndPaint(a0, a1);
    } __finally {
        _PrintExit("EndPaint(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EndPath(HDC a0)
{
    _PrintEnter("EndPath(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_EndPath(a0);
    } __finally {
        _PrintExit("EndPath() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EndUpdateResourceA(HANDLE a0,
                                       BOOL a1)
{
    _PrintEnter("EndUpdateResourceA(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EndUpdateResourceA(a0, a1);
    } __finally {
        _PrintExit("EndUpdateResourceA(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EndUpdateResourceW(HANDLE a0,
                                       BOOL a1)
{
    _PrintEnter("EndUpdateResourceW(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EndUpdateResourceW(a0, a1);
    } __finally {
        _PrintExit("EndUpdateResourceW(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumCalendarInfoA(CALINFO_ENUMPROCA a0,
                                      LCID a1,
                                      CALID a2,
                                      CALTYPE a3)
{
    _PrintEnter("EnumCalendarInfoA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_EnumCalendarInfoA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("EnumCalendarInfoA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumCalendarInfoW(CALINFO_ENUMPROCW a0,
                                      LCID a1,
                                      CALID a2,
                                      CALTYPE a3)
{
    _PrintEnter("EnumCalendarInfoW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_EnumCalendarInfoW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("EnumCalendarInfoW(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumChildWindows(HWND a0,
                                     WNDENUMPROC a1,
                                     LPARAM a2)
{
    _PrintEnter("EnumChildWindows(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumChildWindows(a0, a1, a2);
    } __finally {
        _PrintExit("EnumChildWindows(,,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_EnumClipboardFormats(UINT a0)
{
    _PrintEnter("EnumClipboardFormats(%lx)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_EnumClipboardFormats(a0);
    } __finally {
        _PrintExit("EnumClipboardFormats() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumDateFormatsA(DATEFMT_ENUMPROCA a0,
                                     LCID a1,
                                     DWORD a2)
{
    _PrintEnter("EnumDateFormatsA(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumDateFormatsA(a0, a1, a2);
    } __finally {
        _PrintExit("EnumDateFormatsA(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumDateFormatsW(DATEFMT_ENUMPROCW a0,
                                     LCID a1,
                                     DWORD a2)
{
    _PrintEnter("EnumDateFormatsW(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumDateFormatsW(a0, a1, a2);
    } __finally {
        _PrintExit("EnumDateFormatsW(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumDesktopWindows(HDESK a0,
                                       WNDENUMPROC a1,
                                       LPARAM a2)
{
    _PrintEnter("EnumDesktopWindows(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumDesktopWindows(a0, a1, a2);
    } __finally {
        _PrintExit("EnumDesktopWindows(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumDesktopsA(HWINSTA a0,
                                  DESKTOPENUMPROCA a1,
                                  LPARAM a2)
{
    _PrintEnter("EnumDesktopsA(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumDesktopsA(a0, a1, a2);
    } __finally {
        _PrintExit("EnumDesktopsA(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumDesktopsW(HWINSTA a0,
                                  DESKTOPENUMPROCW a1,
                                  LPARAM a2)
{
    _PrintEnter("EnumDesktopsW(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumDesktopsW(a0, a1, a2);
    } __finally {
        _PrintExit("EnumDesktopsW(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumDisplaySettingsA(LPCSTR a0,
                                         DWORD a1,
                                         LPDEVMODEA a2)
{
    _PrintEnter("EnumDisplaySettingsA(%hs,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumDisplaySettingsA(a0, a1, a2);
    } __finally {
        _PrintExit("EnumDisplaySettingsA(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumDisplaySettingsW(LPCWSTR a0,
                                         DWORD a1,
                                         LPDEVMODEW a2)
{
    _PrintEnter("EnumDisplaySettingsW(%ls,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumDisplaySettingsW(a0, a1, a2);
    } __finally {
        _PrintExit("EnumDisplaySettingsW(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumEnhMetaFile(HDC a0,
                                    HENHMETAFILE a1,
                                    ENHMFENUMPROC a2,
                                    LPVOID a3,
                                    RECT* a4)
{
    _PrintEnter("EnumEnhMetaFile(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_EnumEnhMetaFile(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("EnumEnhMetaFile(,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumFontFamiliesA(HDC a0,
                                     LPCSTR a1,
                                     FONTENUMPROCA a2,
                                     LPARAM a3)
{
    _PrintEnter("EnumFontFamiliesA(%lx,%hs,%lx,%lx)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_EnumFontFamiliesA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("EnumFontFamiliesA(,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumFontFamiliesExA(HDC a0,
                                       LPLOGFONTA a1,
                                       FONTENUMPROCA a2,
                                       LPARAM a3,
                                       DWORD a4)
{
    _PrintEnter("EnumFontFamiliesExA(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_EnumFontFamiliesExA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("EnumFontFamiliesExA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumFontFamiliesExW(HDC a0,
                                       LPLOGFONTW a1,
                                       FONTENUMPROCW a2,
                                       LPARAM a3,
                                       DWORD a4)
{
    _PrintEnter("EnumFontFamiliesExW(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_EnumFontFamiliesExW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("EnumFontFamiliesExW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumFontFamiliesW(HDC a0,
                                     LPCWSTR a1,
                                     FONTENUMPROCW a2,
                                     LPARAM a3)
{
    _PrintEnter("EnumFontFamiliesW(%lx,%ls,%lx,%lx)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_EnumFontFamiliesW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("EnumFontFamiliesW(,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumFontsA(HDC a0,
                              LPCSTR a1,
                              FONTENUMPROCA a2,
                              LPARAM a3)
{
    _PrintEnter("EnumFontsA(%lx,%hs,%lx,%lx)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_EnumFontsA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("EnumFontsA(,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumFontsW(HDC a0,
                              LPCWSTR a1,
                              FONTENUMPROCW a2,
                              LPARAM a3)
{
    _PrintEnter("EnumFontsW(%lx,%ls,%lx,%lx)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_EnumFontsW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("EnumFontsW(,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumICMProfilesA(HDC a0,
                                    ICMENUMPROCA a1,
                                    LPARAM a2)
{
    _PrintEnter("EnumICMProfilesA(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_EnumICMProfilesA(a0, a1, a2);
    } __finally {
        _PrintExit("EnumICMProfilesA(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumICMProfilesW(HDC a0,
                                    ICMENUMPROCW a1,
                                    LPARAM a2)
{
    _PrintEnter("EnumICMProfilesW(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_EnumICMProfilesW(a0, a1, a2);
    } __finally {
        _PrintExit("EnumICMProfilesW(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumMetaFile(HDC a0,
                                 HMETAFILE a1,
                                 MFENUMPROC a2,
                                 LPARAM a3)
{
    _PrintEnter("EnumMetaFile(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_EnumMetaFile(a0, a1, a2, a3);
    } __finally {
        _PrintExit("EnumMetaFile(,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumObjects(HDC a0,
                               int a1,
                               GOBJENUMPROC a2,
                               LPARAM a3)
{
    _PrintEnter("EnumObjects(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_EnumObjects(a0, a1, a2, a3);
    } __finally {
        _PrintExit("EnumObjects(,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumPropsA(HWND a0,
                              PROPENUMPROCA a1)
{
    _PrintEnter("EnumPropsA(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_EnumPropsA(a0, a1);
    } __finally {
        _PrintExit("EnumPropsA(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumPropsExA(HWND a0,
                                PROPENUMPROCEXA a1,
                                LPARAM a2)
{
    _PrintEnter("EnumPropsExA(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_EnumPropsExA(a0, a1, a2);
    } __finally {
        _PrintExit("EnumPropsExA(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumPropsExW(HWND a0,
                                PROPENUMPROCEXW a1,
                                LPARAM a2)
{
    _PrintEnter("EnumPropsExW(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_EnumPropsExW(a0, a1, a2);
    } __finally {
        _PrintExit("EnumPropsExW(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_EnumPropsW(HWND a0,
                              PROPENUMPROCW a1)
{
    _PrintEnter("EnumPropsW(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_EnumPropsW(a0, a1);
    } __finally {
        _PrintExit("EnumPropsW(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumResourceLanguagesA(HMODULE a0,
                                           LPCSTR a1,
                                           LPCSTR a2,
                                           ENUMRESLANGPROCA a3,
                                           LONG_PTR a4)
{
    _PrintEnter("EnumResourceLanguagesA(%lx,%hs,%hs,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_EnumResourceLanguagesA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("EnumResourceLanguagesA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumResourceLanguagesW(HMODULE a0,
                                           LPCWSTR a1,
                                           LPCWSTR a2,
                                           ENUMRESLANGPROCW a3,
                                           LONG_PTR a4)
{
    _PrintEnter("EnumResourceLanguagesW(%lx,%ls,%ls,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_EnumResourceLanguagesW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("EnumResourceLanguagesW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumResourceNamesA(HMODULE a0,
                                       LPCSTR a1,
                                       ENUMRESNAMEPROCA a2,
                                       LONG_PTR a3)
{
    _PrintEnter("EnumResourceNamesA(%lx,%hs,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_EnumResourceNamesA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("EnumResourceNamesA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumResourceNamesW(HMODULE a0,
                                       LPCWSTR a1,
                                       ENUMRESNAMEPROCW a2,
                                       LONG_PTR a3)
{
    _PrintEnter("EnumResourceNamesW(%lx,%ls,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_EnumResourceNamesW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("EnumResourceNamesW(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumResourceTypesA(HMODULE a0,
                                       ENUMRESTYPEPROCA a1,
                                       LONG_PTR a2)
{
    _PrintEnter("EnumResourceTypesA(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumResourceTypesA(a0, a1, a2);
    } __finally {
        _PrintExit("EnumResourceTypesA(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumResourceTypesW(HMODULE a0,
                                       ENUMRESTYPEPROCW a1,
                                       LONG_PTR a2)
{
    _PrintEnter("EnumResourceTypesW(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumResourceTypesW(a0, a1, a2);
    } __finally {
        _PrintExit("EnumResourceTypesW(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumSystemCodePagesA(CODEPAGE_ENUMPROCA a0,
                                         DWORD a1)
{
    _PrintEnter("EnumSystemCodePagesA(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EnumSystemCodePagesA(a0, a1);
    } __finally {
        _PrintExit("EnumSystemCodePagesA(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumSystemCodePagesW(CODEPAGE_ENUMPROCW a0,
                                         DWORD a1)
{
    _PrintEnter("EnumSystemCodePagesW(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EnumSystemCodePagesW(a0, a1);
    } __finally {
        _PrintExit("EnumSystemCodePagesW(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumSystemLocalesA(LOCALE_ENUMPROCA a0,
                                       DWORD a1)
{
    _PrintEnter("EnumSystemLocalesA(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EnumSystemLocalesA(a0, a1);
    } __finally {
        _PrintExit("EnumSystemLocalesA(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumSystemLocalesW(LOCALE_ENUMPROCW a0,
                                       DWORD a1)
{
    _PrintEnter("EnumSystemLocalesW(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EnumSystemLocalesW(a0, a1);
    } __finally {
        _PrintExit("EnumSystemLocalesW(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumThreadWindows(DWORD a0,
                                      WNDENUMPROC a1,
                                      LPARAM a2)
{
    _PrintEnter("EnumThreadWindows(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumThreadWindows(a0, a1, a2);
    } __finally {
        _PrintExit("EnumThreadWindows(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumTimeFormatsA(TIMEFMT_ENUMPROCA a0,
                                     LCID a1,
                                     DWORD a2)
{
    _PrintEnter("EnumTimeFormatsA(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumTimeFormatsA(a0, a1, a2);
    } __finally {
        _PrintExit("EnumTimeFormatsA(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumTimeFormatsW(TIMEFMT_ENUMPROCW a0,
                                     LCID a1,
                                     DWORD a2)
{
    _PrintEnter("EnumTimeFormatsW(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_EnumTimeFormatsW(a0, a1, a2);
    } __finally {
        _PrintExit("EnumTimeFormatsW(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumWindowStationsA(WINSTAENUMPROCA a0,
                                        LPARAM a1)
{
    _PrintEnter("EnumWindowStationsA(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EnumWindowStationsA(a0, a1);
    } __finally {
        _PrintExit("EnumWindowStationsA(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumWindowStationsW(WINSTAENUMPROCW a0,
                                        LPARAM a1)
{
    _PrintEnter("EnumWindowStationsW(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EnumWindowStationsW(a0, a1);
    } __finally {
        _PrintExit("EnumWindowStationsW(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EnumWindows(WNDENUMPROC a0,
                                LPARAM a1)
{
    _PrintEnter("EnumWindows(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EnumWindows(a0, a1);
    } __finally {
        _PrintExit("EnumWindows(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EqualRect(RECT* a0,
                              RECT* a1)
{
    _PrintEnter("EqualRect(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EqualRect(a0, a1);
    } __finally {
        _PrintExit("EqualRect(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EqualRgn(HRGN a0,
                             HRGN a1)
{
    _PrintEnter("EqualRgn(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EqualRgn(a0, a1);
    } __finally {
        _PrintExit("EqualRgn(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_EraseTape(HANDLE a0,
                               DWORD a1,
                               BOOL a2)
{
    _PrintEnter("EraseTape(%lx,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_EraseTape(a0, a1, a2);
    } __finally {
        _PrintExit("EraseTape(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_Escape(HDC a0,
                          int a1,
                          int a2,
                          LPCSTR a3,
                          LPVOID a4)
{
    _PrintEnter("Escape(%lx,%lx,%lx,%hs,%lx)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_Escape(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("Escape(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_EscapeCommFunction(HANDLE a0,
                                       DWORD a1)
{
    _PrintEnter("EscapeCommFunction(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_EscapeCommFunction(a0, a1);
    } __finally {
        _PrintExit("EscapeCommFunction(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_ExcludeClipRect(HDC a0,
                                   int a1,
                                   int a2,
                                   int a3,
                                   int a4)
{
    _PrintEnter("ExcludeClipRect(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_ExcludeClipRect(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ExcludeClipRect(,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_ExcludeUpdateRgn(HDC a0,
                                    HWND a1)
{
    _PrintEnter("ExcludeUpdateRgn(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_ExcludeUpdateRgn(a0, a1);
    } __finally {
        _PrintExit("ExcludeUpdateRgn(,) -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_ExitProcess(UINT a0)
{
    _PrintEnter("ExitProcess(%lx)\n", a0);

    __try {
        Real_ExitProcess(a0);
    } __finally {
        _PrintExit("ExitProcess() ->\n");
    };
}

void __stdcall Mine_ExitThread(DWORD a0)
{
    _PrintEnter("ExitThread(%lx)\n", a0);

    __try {
        Real_ExitThread(a0);
    } __finally {
        _PrintExit("ExitThread() ->\n");
    };
}

BOOL __stdcall Mine_ExitWindowsEx(UINT a0,
                                  DWORD a1)
{
    _PrintEnter("ExitWindowsEx(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_ExitWindowsEx(a0, a1);
    } __finally {
        _PrintExit("ExitWindowsEx(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_ExpandEnvironmentStringsA(LPCSTR a0,
                                               LPSTR a1,
                                               DWORD a2)
{
    _PrintEnter("ExpandEnvironmentStringsA(%hs,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_ExpandEnvironmentStringsA(a0, a1, a2);
    } __finally {
        _PrintExit("ExpandEnvironmentStringsA(,%hs,) -> %lx\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_ExpandEnvironmentStringsW(LPCWSTR a0,
                                               LPWSTR a1,
                                               DWORD a2)
{
    _PrintEnter("ExpandEnvironmentStringsW(%ls,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_ExpandEnvironmentStringsW(a0, a1, a2);
    } __finally {
        _PrintExit("ExpandEnvironmentStringsW(,%ls,) -> %lx\n", a1, rv);
    };
    return rv;
}

HPEN __stdcall Mine_ExtCreatePen(DWORD a0,
                                 DWORD a1,
                                 struct tagLOGBRUSH* a2,
                                 DWORD a3,
                                 DWORD* a4)
{
    _PrintEnter("ExtCreatePen(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    HPEN rv = 0;
    __try {
        rv = Real_ExtCreatePen(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ExtCreatePen(,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRGN __stdcall Mine_ExtCreateRegion(XFORM* a0,
                                    DWORD a1,
                                    RGNDATA* a2)
{
    _PrintEnter("ExtCreateRegion(%lx,%lx,%lx)\n", a0, a1, a2);

    HRGN rv = 0;
    __try {
        rv = Real_ExtCreateRegion(a0, a1, a2);
    } __finally {
        _PrintExit("ExtCreateRegion(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_ExtEscape(HDC a0,
                             int a1,
                             int a2,
                             LPCSTR a3,
                             int a4,
                             LPSTR a5)
{
    _PrintEnter("ExtEscape(%lx,%lx,%lx,%hs,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_ExtEscape(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("ExtEscape(,,,,,%hs) -> %lx\n", a5, rv);
    };
    return rv;
}

BOOL __stdcall Mine_ExtFloodFill(HDC a0,
                                 int a1,
                                 int a2,
                                 COLORREF a3,
                                 UINT a4)
{
    _PrintEnter("ExtFloodFill(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ExtFloodFill(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ExtFloodFill(,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_ExtSelectClipRgn(HDC a0,
                                    HRGN a1,
                                    int a2)
{
    _PrintEnter("ExtSelectClipRgn(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_ExtSelectClipRgn(a0, a1, a2);
    } __finally {
        _PrintExit("ExtSelectClipRgn(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ExtTextOutA(HDC a0,
                                int a1,
                                int a2,
                                UINT a3,
                                RECT* a4,
                                LPCSTR a5,
                                UINT a6,
                                INT* a7)
{
    _PrintEnter("ExtTextOutA(%lx,%lx,%lx,%lx,%lx,%hs,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    BOOL rv = 0;
    __try {
        rv = Real_ExtTextOutA(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("ExtTextOutA(,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ExtTextOutW(HDC a0,
                                int a1,
                                int a2,
                                UINT a3,
                                RECT* a4,
                                LPCWSTR a5,
                                UINT a6,
                                INT* a7)
{
    _PrintEnter("ExtTextOutW(%lx,%lx,%lx,%lx,%lx,%ls,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    BOOL rv = 0;
    __try {
        rv = Real_ExtTextOutW(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("ExtTextOutW(,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_FatalAppExitA(UINT a0,
                                  LPCSTR a1)
{
    _PrintEnter("FatalAppExitA(%lx,%hs)\n", a0, a1);

    __try {
        Real_FatalAppExitA(a0, a1);
    } __finally {
        _PrintExit("FatalAppExitA(,) ->\n");
    };
}

void __stdcall Mine_FatalAppExitW(UINT a0,
                                  LPCWSTR a1)
{
    _PrintEnter("FatalAppExitW(%lx,%ls)\n", a0, a1);

    __try {
        Real_FatalAppExitW(a0, a1);
    } __finally {
        _PrintExit("FatalAppExitW(,) ->\n");
    };
}

void __stdcall Mine_FatalExit(int a0)
{
    _PrintEnter("FatalExit(%lx)\n", a0);

    __try {
        Real_FatalExit(a0);
    } __finally {
        _PrintExit("FatalExit() ->\n");
    };
}

BOOL __stdcall Mine_FileTimeToDosDateTime(FILETIME* a0,
                                          LPWORD a1,
                                          LPWORD a2)
{
    _PrintEnter("FileTimeToDosDateTime(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_FileTimeToDosDateTime(a0, a1, a2);
    } __finally {
        _PrintExit("FileTimeToDosDateTime(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FileTimeToLocalFileTime(FILETIME* a0,
                                            LPFILETIME a1)
{
    _PrintEnter("FileTimeToLocalFileTime(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_FileTimeToLocalFileTime(a0, a1);
    } __finally {
        _PrintExit("FileTimeToLocalFileTime(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FileTimeToSystemTime(FILETIME* a0,
                                         struct _SYSTEMTIME* a1)
{
    _PrintEnter("FileTimeToSystemTime(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_FileTimeToSystemTime(a0, a1);
    } __finally {
        _PrintExit("FileTimeToSystemTime(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FillConsoleOutputAttribute(HANDLE a0,
                                               WORD a1,
                                               DWORD a2,
                                               COORD a3,
                                               LPDWORD a4)
{
    _PrintEnter("FillConsoleOutputAttribute(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_FillConsoleOutputAttribute(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("FillConsoleOutputAttribute(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FillConsoleOutputCharacterA(HANDLE a0,
                                                CHAR a1,
                                                DWORD a2,
                                                COORD a3,
                                                LPDWORD a4)
{
    _PrintEnter("FillConsoleOutputCharacterA(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_FillConsoleOutputCharacterA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("FillConsoleOutputCharacterA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FillConsoleOutputCharacterW(HANDLE a0,
                                                WCHAR a1,
                                                DWORD a2,
                                                COORD a3,
                                                LPDWORD a4)
{
    _PrintEnter("FillConsoleOutputCharacterW(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_FillConsoleOutputCharacterW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("FillConsoleOutputCharacterW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FillPath(HDC a0)
{
    _PrintEnter("FillPath(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_FillPath(a0);
    } __finally {
        _PrintExit("FillPath() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_FillRect(HDC a0,
                            RECT* a1,
                            HBRUSH a2)
{
    _PrintEnter("FillRect(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_FillRect(a0, a1, a2);
    } __finally {
        _PrintExit("FillRect(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FillRgn(HDC a0,
                            HRGN a1,
                            HBRUSH a2)
{
    _PrintEnter("FillRgn(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_FillRgn(a0, a1, a2);
    } __finally {
        _PrintExit("FillRgn(,,) -> %lx\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_FindAtomA(LPCSTR a0)
{
    _PrintEnter("FindAtomA(%hs)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_FindAtomA(a0);
    } __finally {
        _PrintExit("FindAtomA() -> %lx\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_FindAtomW(LPCWSTR a0)
{
    _PrintEnter("FindAtomW(%ls)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_FindAtomW(a0);
    } __finally {
        _PrintExit("FindAtomW() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FindClose(HANDLE a0)
{
    _PrintEnter("FindClose(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_FindClose(a0);
    } __finally {
        _PrintExit("FindClose() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FindCloseChangeNotification(HANDLE a0)
{
    _PrintEnter("FindCloseChangeNotification(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_FindCloseChangeNotification(a0);
    } __finally {
        _PrintExit("FindCloseChangeNotification() -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_FindFirstChangeNotificationA(LPCSTR a0,
                                                   BOOL a1,
                                                   DWORD a2)
{
    _PrintEnter("FindFirstChangeNotificationA(%hs,%lx,%lx)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_FindFirstChangeNotificationA(a0, a1, a2);
    } __finally {
        _PrintExit("FindFirstChangeNotificationA(,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_FindFirstChangeNotificationW(LPCWSTR a0,
                                                   BOOL a1,
                                                   DWORD a2)
{
    _PrintEnter("FindFirstChangeNotificationW(%ls,%lx,%lx)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_FindFirstChangeNotificationW(a0, a1, a2);
    } __finally {
        _PrintExit("FindFirstChangeNotificationW(,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_FindFirstFileA(LPCSTR a0,
                                     LPWIN32_FIND_DATAA a1)
{
    _PrintEnter("FindFirstFileA(%hs,%lx)\n", a0, a1);

    HANDLE rv = 0;
    __try {
        rv = Real_FindFirstFileA(a0, a1);
    } __finally {
        _PrintExit("FindFirstFileA(,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_FindFirstFileExA(LPCSTR a0,
                                       FINDEX_INFO_LEVELS a1,
                                       LPVOID a2,
                                       FINDEX_SEARCH_OPS a3,
                                       LPVOID a4,
                                       DWORD a5)
{
    _PrintEnter("FindFirstFileExA(%hs,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    HANDLE rv = 0;
    __try {
        rv = Real_FindFirstFileExA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("FindFirstFileExA(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_FindFirstFileExW(LPCWSTR a0,
                                       FINDEX_INFO_LEVELS a1,
                                       LPVOID a2,
                                       FINDEX_SEARCH_OPS a3,
                                       LPVOID a4,
                                       DWORD a5)
{
    _PrintEnter("FindFirstFileExW(%ls,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    HANDLE rv = 0;
    __try {
        rv = Real_FindFirstFileExW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("FindFirstFileExW(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_FindFirstFileW(LPCWSTR a0,
                                     LPWIN32_FIND_DATAW a1)
{
    _PrintEnter("FindFirstFileW(%ls,%lx)\n", a0, a1);

    HANDLE rv = 0;
    __try {
        rv = Real_FindFirstFileW(a0, a1);
    } __finally {
        _PrintExit("FindFirstFileW(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FindNextChangeNotification(HANDLE a0)
{
    _PrintEnter("FindNextChangeNotification(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_FindNextChangeNotification(a0);
    } __finally {
        _PrintExit("FindNextChangeNotification() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FindNextFileA(HANDLE a0,
                                  LPWIN32_FIND_DATAA a1)
{
    _PrintEnter("FindNextFileA(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_FindNextFileA(a0, a1);
    } __finally {
        _PrintExit("FindNextFileA(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FindNextFileW(HANDLE a0,
                                  LPWIN32_FIND_DATAW a1)
{
    _PrintEnter("FindNextFileW(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_FindNextFileW(a0, a1);
    } __finally {
        _PrintExit("FindNextFileW(,) -> %lx\n", rv);
    };
    return rv;
}

HRSRC __stdcall Mine_FindResourceA(HMODULE a0,
                                   LPCSTR a1,
                                   LPCSTR a2)
{
    _PrintEnter("FindResourceA(%lx,%hs,%hs)\n", a0, a1, a2);

    HRSRC rv = 0;
    __try {
        rv = Real_FindResourceA(a0, a1, a2);
    } __finally {
        _PrintExit("FindResourceA(,,) -> %lx\n", rv);
    };
    return rv;
}

HRSRC __stdcall Mine_FindResourceExA(HMODULE a0,
                                     LPCSTR a1,
                                     LPCSTR a2,
                                     WORD a3)
{
    _PrintEnter("FindResourceExA(%lx,%hs,%hs,%lx)\n", a0, a1, a2, a3);

    HRSRC rv = 0;
    __try {
        rv = Real_FindResourceExA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("FindResourceExA(,,,) -> %lx\n", rv);
    };
    return rv;
}

HRSRC __stdcall Mine_FindResourceExW(HMODULE a0,
                                     LPCWSTR a1,
                                     LPCWSTR a2,
                                     WORD a3)
{
    _PrintEnter("FindResourceExW(%lx,%ls,%ls,%lx)\n", a0, a1, a2, a3);

    HRSRC rv = 0;
    __try {
        rv = Real_FindResourceExW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("FindResourceExW(,,,) -> %lx\n", rv);
    };
    return rv;
}

HRSRC __stdcall Mine_FindResourceW(HMODULE a0,
                                   LPCWSTR a1,
                                   LPCWSTR a2)
{
    _PrintEnter("FindResourceW(%lx,%ls,%ls)\n", a0, a1, a2);

    HRSRC rv = 0;
    __try {
        rv = Real_FindResourceW(a0, a1, a2);
    } __finally {
        _PrintExit("FindResourceW(,,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_FindWindowA(LPCSTR a0,
                                LPCSTR a1)
{
    _PrintEnter("FindWindowA(%hs,%hs)\n", a0, a1);

    HWND rv = 0;
    __try {
        rv = Real_FindWindowA(a0, a1);
    } __finally {
        _PrintExit("FindWindowA(,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_FindWindowExA(HWND a0,
                                  HWND a1,
                                  LPCSTR a2,
                                  LPCSTR a3)
{
    _PrintEnter("FindWindowExA(%lx,%lx,%hs,%hs)\n", a0, a1, a2, a3);

    HWND rv = 0;
    __try {
        rv = Real_FindWindowExA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("FindWindowExA(,,,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_FindWindowExW(HWND a0,
                                  HWND a1,
                                  LPCWSTR a2,
                                  LPCWSTR a3)
{
    _PrintEnter("FindWindowExW(%lx,%lx,%ls,%ls)\n", a0, a1, a2, a3);

    HWND rv = 0;
    __try {
        rv = Real_FindWindowExW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("FindWindowExW(,,,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_FindWindowW(LPCWSTR a0,
                                LPCWSTR a1)
{
    _PrintEnter("FindWindowW(%ls,%ls)\n", a0, a1);

    HWND rv = 0;
    __try {
        rv = Real_FindWindowW(a0, a1);
    } __finally {
        _PrintExit("FindWindowW(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FixBrushOrgEx(HDC a0,
                                  int a1,
                                  int a2,
                                  struct tagPOINT* a3)
{
    _PrintEnter("FixBrushOrgEx(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_FixBrushOrgEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("FixBrushOrgEx(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FlashWindow(HWND a0,
                                BOOL a1)
{
    _PrintEnter("FlashWindow(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_FlashWindow(a0, a1);
    } __finally {
        _PrintExit("FlashWindow(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FlattenPath(HDC a0)
{
    _PrintEnter("FlattenPath(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_FlattenPath(a0);
    } __finally {
        _PrintExit("FlattenPath() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FloodFill(HDC a0,
                              int a1,
                              int a2,
                              COLORREF a3)
{
    _PrintEnter("FloodFill(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_FloodFill(a0, a1, a2, a3);
    } __finally {
        _PrintExit("FloodFill(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FlushConsoleInputBuffer(HANDLE a0)
{
    _PrintEnter("FlushConsoleInputBuffer(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_FlushConsoleInputBuffer(a0);
    } __finally {
        _PrintExit("FlushConsoleInputBuffer() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FlushFileBuffers(HANDLE a0)
{
    _PrintEnter("FlushFileBuffers(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_FlushFileBuffers(a0);
    } __finally {
        _PrintExit("FlushFileBuffers() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FlushViewOfFile(LPCVOID a0,
                                    SIZE_T a1)
{
    _PrintEnter("FlushViewOfFile(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_FlushViewOfFile(a0, a1);
    } __finally {
        _PrintExit("FlushViewOfFile(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_FmtIdToPropStgName(FMTID* a0,
                                          LPOLESTR a1)
{
    _PrintEnter("FmtIdToPropStgName(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_FmtIdToPropStgName(a0, a1);
    } __finally {
        _PrintExit("FmtIdToPropStgName(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_FoldStringA(DWORD a0,
                               LPCSTR a1,
                               int a2,
                               LPSTR a3,
                               int a4)
{
    _PrintEnter("FoldStringA(%lx,%hs,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_FoldStringA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("FoldStringA(,,,%hs,) -> %lx\n", a3, rv);
    };
    return rv;
}

int __stdcall Mine_FoldStringW(DWORD a0,
                               LPCWSTR a1,
                               int a2,
                               LPWSTR a3,
                               int a4)
{
    _PrintEnter("FoldStringW(%lx,%ls,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_FoldStringW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("FoldStringW(,,,%ls,) -> %lx\n", a3, rv);
    };
    return rv;
}

DWORD __stdcall Mine_FormatMessageA(DWORD a0,
                                    LPCVOID a1,
                                    DWORD a2,
                                    DWORD a3,
                                    LPSTR a4,
                                    DWORD a5,
                                    va_list* a6)
{
    _PrintEnter("FormatMessageA(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    DWORD rv = 0;
    __try {
        rv = Real_FormatMessageA(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("FormatMessageA(,,,,%hs,,) -> %lx\n", a4, rv);
    };
    return rv;
}

DWORD __stdcall Mine_FormatMessageW(DWORD a0,
                                    LPCVOID a1,
                                    DWORD a2,
                                    DWORD a3,
                                    LPWSTR a4,
                                    DWORD a5,
                                    va_list* a6)
{
    _PrintEnter("FormatMessageW(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    DWORD rv = 0;
    __try {
        rv = Real_FormatMessageW(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("FormatMessageW(,,,,%ls,,) -> %lx\n", a4, rv);
    };
    return rv;
}

int __stdcall Mine_FrameRect(HDC a0,
                             RECT* a1,
                             HBRUSH a2)
{
    _PrintEnter("FrameRect(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_FrameRect(a0, a1, a2);
    } __finally {
        _PrintExit("FrameRect(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FrameRgn(HDC a0,
                             HRGN a1,
                             HBRUSH a2,
                             int a3,
                             int a4)
{
    _PrintEnter("FrameRgn(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_FrameRgn(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("FrameRgn(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FreeConsole(void)
{
    _PrintEnter("FreeConsole()\n");

    BOOL rv = 0;
    __try {
        rv = Real_FreeConsole();
    } __finally {
        _PrintExit("FreeConsole() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FreeDDElParam(UINT a0,
                                  LPARAM a1)
{
    _PrintEnter("FreeDDElParam(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_FreeDDElParam(a0, a1);
    } __finally {
        _PrintExit("FreeDDElParam(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FreeEnvironmentStringsA(LPSTR a0)
{
    _PrintEnter("FreeEnvironmentStringsA(%hs)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_FreeEnvironmentStringsA(a0);
    } __finally {
        _PrintExit("FreeEnvironmentStringsA() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FreeEnvironmentStringsW(LPWSTR a0)
{
    _PrintEnter("FreeEnvironmentStringsW(%ls)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_FreeEnvironmentStringsW(a0);
    } __finally {
        _PrintExit("FreeEnvironmentStringsW() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FreeLibrary(HMODULE a0)
{
    _PrintEnter("FreeLibrary(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_FreeLibrary(a0);
    } __finally {
        _PrintExit("FreeLibrary() -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_FreeLibraryAndExitThread(HMODULE a0,
                                             DWORD a1)
{
    _PrintEnter("FreeLibraryAndExitThread(%lx,%lx)\n", a0, a1);

    __try {
        Real_FreeLibraryAndExitThread(a0, a1);
    } __finally {
        _PrintExit("FreeLibraryAndExitThread(,) ->\n");
    };
}

HRESULT __stdcall Mine_FreePropVariantArray(ULONG a0,
                                            PROPVARIANT* a1)
{
    _PrintEnter("FreePropVariantArray(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_FreePropVariantArray(a0, a1);
    } __finally {
        _PrintExit("FreePropVariantArray(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_FreeResource(HGLOBAL a0)
{
    _PrintEnter("FreeResource(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_FreeResource(a0);
    } __finally {
        _PrintExit("FreeResource() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GdiComment(HDC a0,
                               UINT a1,
                               BYTE* a2)
{
    _PrintEnter("GdiComment(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GdiComment(a0, a1, a2);
    } __finally {
        _PrintExit("GdiComment(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GdiFlush(void)
{
    _PrintEnter("GdiFlush()\n");

    BOOL rv = 0;
    __try {
        rv = Real_GdiFlush();
    } __finally {
        _PrintExit("GdiFlush() -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GdiGetBatchLimit(void)
{
    _PrintEnter("GdiGetBatchLimit()\n");

    DWORD rv = 0;
    __try {
        rv = Real_GdiGetBatchLimit();
    } __finally {
        _PrintExit("GdiGetBatchLimit() -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GdiSetBatchLimit(DWORD a0)
{
    _PrintEnter("GdiSetBatchLimit(%lx)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GdiSetBatchLimit(a0);
    } __finally {
        _PrintExit("GdiSetBatchLimit() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GenerateConsoleCtrlEvent(DWORD a0,
                                             DWORD a1)
{
    _PrintEnter("GenerateConsoleCtrlEvent(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GenerateConsoleCtrlEvent(a0, a1);
    } __finally {
        _PrintExit("GenerateConsoleCtrlEvent(,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetACP(void)
{
    _PrintEnter("GetACP()\n");

    UINT rv = 0;
    __try {
        rv = Real_GetACP();
    } __finally {
        _PrintExit("GetACP() -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetActiveWindow(void)
{
    _PrintEnter("GetActiveWindow()\n");

    HWND rv = 0;
    __try {
        rv = Real_GetActiveWindow();
    } __finally {
        _PrintExit("GetActiveWindow() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetArcDirection(HDC a0)
{
    _PrintEnter("GetArcDirection(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetArcDirection(a0);
    } __finally {
        _PrintExit("GetArcDirection() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetAspectRatioFilterEx(HDC a0,
                                           struct tagSIZE* a1)
{
    _PrintEnter("GetAspectRatioFilterEx(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetAspectRatioFilterEx(a0, a1);
    } __finally {
        _PrintExit("GetAspectRatioFilterEx(,) -> %lx\n", rv);
    };
    return rv;
}

SHORT __stdcall Mine_GetAsyncKeyState(int a0)
{
    _PrintEnter("GetAsyncKeyState(%lx)\n", a0);

    SHORT rv = 0;
    __try {
        rv = Real_GetAsyncKeyState(a0);
    } __finally {
        _PrintExit("GetAsyncKeyState() -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetAtomNameA(ATOM a0,
                                 LPSTR a1,
                                 int a2)
{
    _PrintEnter("GetAtomNameA(%lx,%lx,%lx)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetAtomNameA(a0, a1, a2);
    } __finally {
        _PrintExit("GetAtomNameA(,%hs,) -> %lx\n", a1, rv);
    };
    return rv;
}

UINT __stdcall Mine_GetAtomNameW(ATOM a0,
                                 LPWSTR a1,
                                 int a2)
{
    _PrintEnter("GetAtomNameW(%lx,%lx,%lx)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetAtomNameW(a0, a1, a2);
    } __finally {
        _PrintExit("GetAtomNameW(,%ls,) -> %lx\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetBinaryTypeA(LPCSTR a0,
                                   LPDWORD a1)
{
    _PrintEnter("GetBinaryTypeA(%hs,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetBinaryTypeA(a0, a1);
    } __finally {
        _PrintExit("GetBinaryTypeA(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetBinaryTypeW(LPCWSTR a0,
                                   LPDWORD a1)
{
    _PrintEnter("GetBinaryTypeW(%ls,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetBinaryTypeW(a0, a1);
    } __finally {
        _PrintExit("GetBinaryTypeW(,) -> %lx\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_GetBitmapBits(HBITMAP a0,
                                  LONG a1,
                                  LPVOID a2)
{
    _PrintEnter("GetBitmapBits(%lx,%lx,%lx)\n", a0, a1, a2);

    LONG rv = 0;
    __try {
        rv = Real_GetBitmapBits(a0, a1, a2);
    } __finally {
        _PrintExit("GetBitmapBits(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetBitmapDimensionEx(HBITMAP a0,
                                         struct tagSIZE* a1)
{
    _PrintEnter("GetBitmapDimensionEx(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetBitmapDimensionEx(a0, a1);
    } __finally {
        _PrintExit("GetBitmapDimensionEx(,) -> %lx\n", rv);
    };
    return rv;
}

COLORREF __stdcall Mine_GetBkColor(HDC a0)
{
    _PrintEnter("GetBkColor(%lx)\n", a0);

    COLORREF rv = 0;
    __try {
        rv = Real_GetBkColor(a0);
    } __finally {
        _PrintExit("GetBkColor() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetBkMode(HDC a0)
{
    _PrintEnter("GetBkMode(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetBkMode(a0);
    } __finally {
        _PrintExit("GetBkMode() -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetBoundsRect(HDC a0,
                                  LPRECT a1,
                                  UINT a2)
{
    _PrintEnter("GetBoundsRect(%lx,%lx,%lx)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetBoundsRect(a0, a1, a2);
    } __finally {
        _PrintExit("GetBoundsRect(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetBrushOrgEx(HDC a0,
                                  struct tagPOINT* a1)
{
    _PrintEnter("GetBrushOrgEx(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetBrushOrgEx(a0, a1);
    } __finally {
        _PrintExit("GetBrushOrgEx(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCPInfo(UINT a0,
                              struct _cpinfo* a1)
{
    _PrintEnter("GetCPInfo(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetCPInfo(a0, a1);
    } __finally {
        _PrintExit("GetCPInfo(,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetCapture(void)
{
    _PrintEnter("GetCapture()\n");

    HWND rv = 0;
    __try {
        rv = Real_GetCapture();
    } __finally {
        _PrintExit("GetCapture() -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetCaretBlinkTime(void)
{
    _PrintEnter("GetCaretBlinkTime()\n");

    UINT rv = 0;
    __try {
        rv = Real_GetCaretBlinkTime();
    } __finally {
        _PrintExit("GetCaretBlinkTime() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCaretPos(struct tagPOINT* a0)
{
    _PrintEnter("GetCaretPos(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_GetCaretPos(a0);
    } __finally {
        _PrintExit("GetCaretPos() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCharABCWidthsA(HDC a0,
                                      UINT a1,
                                      UINT a2,
                                      struct _ABC* a3)
{
    _PrintEnter("GetCharABCWidthsA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetCharABCWidthsA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetCharABCWidthsA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCharABCWidthsFloatA(HDC a0,
                                           UINT a1,
                                           UINT a2,
                                           struct _ABCFLOAT* a3)
{
    _PrintEnter("GetCharABCWidthsFloatA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetCharABCWidthsFloatA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetCharABCWidthsFloatA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCharABCWidthsFloatW(HDC a0,
                                           UINT a1,
                                           UINT a2,
                                           struct _ABCFLOAT* a3)
{
    _PrintEnter("GetCharABCWidthsFloatW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetCharABCWidthsFloatW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetCharABCWidthsFloatW(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCharABCWidthsW(HDC a0,
                                      UINT a1,
                                      UINT a2,
                                      struct _ABC* a3)
{
    _PrintEnter("GetCharABCWidthsW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetCharABCWidthsW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetCharABCWidthsW(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCharWidth32A(HDC a0,
                                    UINT a1,
                                    UINT a2,
                                    LPINT a3)
{
    _PrintEnter("GetCharWidth32A(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetCharWidth32A(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetCharWidth32A(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCharWidth32W(HDC a0,
                                    UINT a1,
                                    UINT a2,
                                    LPINT a3)
{
    _PrintEnter("GetCharWidth32W(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetCharWidth32W(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetCharWidth32W(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCharWidthA(HDC a0,
                                  UINT a1,
                                  UINT a2,
                                  LPINT a3)
{
    _PrintEnter("GetCharWidthA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetCharWidthA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetCharWidthA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCharWidthFloatA(HDC a0,
                                       UINT a1,
                                       UINT a2,
                                       PFLOAT a3)
{
    _PrintEnter("GetCharWidthFloatA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetCharWidthFloatA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetCharWidthFloatA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCharWidthFloatW(HDC a0,
                                       UINT a1,
                                       UINT a2,
                                       PFLOAT a3)
{
    _PrintEnter("GetCharWidthFloatW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetCharWidthFloatW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetCharWidthFloatW(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCharWidthW(HDC a0,
                                  UINT a1,
                                  UINT a2,
                                  LPINT a3)
{
    _PrintEnter("GetCharWidthW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetCharWidthW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetCharWidthW(,,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetCharacterPlacementA(HDC a0,
                                            LPCSTR a1,
                                            int a2,
                                            int a3,
                                            LPGCP_RESULTSA a4,
                                            DWORD a5)
{
    _PrintEnter("GetCharacterPlacementA(%lx,%hs,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    DWORD rv = 0;
    __try {
        rv = Real_GetCharacterPlacementA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("GetCharacterPlacementA(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetCharacterPlacementW(HDC a0,
                                            LPCWSTR a1,
                                            int a2,
                                            int a3,
                                            LPGCP_RESULTSW a4,
                                            DWORD a5)
{
    _PrintEnter("GetCharacterPlacementW(%lx,%ls,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    DWORD rv = 0;
    __try {
        rv = Real_GetCharacterPlacementW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("GetCharacterPlacementW(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_GetClassFile(LPCOLESTR a0,
                                    CLSID* a1)
{
    _PrintEnter("GetClassFile(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_GetClassFile(a0, a1);
    } __finally {
        _PrintExit("GetClassFile(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetClassInfoA(HINSTANCE a0,
                                  LPCSTR a1,
                                  LPWNDCLASSA a2)
{
    _PrintEnter("GetClassInfoA(%lx,%hs,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetClassInfoA(a0, a1, a2);
    } __finally {
        _PrintExit("GetClassInfoA(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetClassInfoExA(HINSTANCE a0,
                                    LPCSTR a1,
                                    LPWNDCLASSEXA a2)
{
    _PrintEnter("GetClassInfoExA(%lx,%hs,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetClassInfoExA(a0, a1, a2);
    } __finally {
        _PrintExit("GetClassInfoExA(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetClassInfoExW(HINSTANCE a0,
                                    LPCWSTR a1,
                                    LPWNDCLASSEXW a2)
{
    _PrintEnter("GetClassInfoExW(%lx,%ls,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetClassInfoExW(a0, a1, a2);
    } __finally {
        _PrintExit("GetClassInfoExW(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetClassInfoW(HINSTANCE a0,
                                  LPCWSTR a1,
                                  LPWNDCLASSW a2)
{
    _PrintEnter("GetClassInfoW(%lx,%ls,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetClassInfoW(a0, a1, a2);
    } __finally {
        _PrintExit("GetClassInfoW(,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetClassLongA(HWND a0,
                                   int a1)
{
    _PrintEnter("GetClassLongA(%lx,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetClassLongA(a0, a1);
    } __finally {
        _PrintExit("GetClassLongA(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetClassLongW(HWND a0,
                                   int a1)
{
    _PrintEnter("GetClassLongW(%lx,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetClassLongW(a0, a1);
    } __finally {
        _PrintExit("GetClassLongW(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetClassNameA(HWND a0,
                                 LPSTR a1,
                                 int a2)
{
    _PrintEnter("GetClassNameA(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetClassNameA(a0, a1, a2);
    } __finally {
        _PrintExit("GetClassNameA(,%hs,) -> %lx\n", a1, rv);
    };
    return rv;
}

int __stdcall Mine_GetClassNameW(HWND a0,
                                 LPWSTR a1,
                                 int a2)
{
    _PrintEnter("GetClassNameW(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetClassNameW(a0, a1, a2);
    } __finally {
        _PrintExit("GetClassNameW(,%ls,) -> %lx\n", a1, rv);
    };
    return rv;
}

WORD __stdcall Mine_GetClassWord(HWND a0,
                                 int a1)
{
    _PrintEnter("GetClassWord(%lx,%lx)\n", a0, a1);

    WORD rv = 0;
    __try {
        rv = Real_GetClassWord(a0, a1);
    } __finally {
        _PrintExit("GetClassWord(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetClientRect(HWND a0,
                                  LPRECT a1)
{
    _PrintEnter("GetClientRect(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetClientRect(a0, a1);
    } __finally {
        _PrintExit("GetClientRect(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetClipBox(HDC a0,
                              LPRECT a1)
{
    _PrintEnter("GetClipBox(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_GetClipBox(a0, a1);
    } __finally {
        _PrintExit("GetClipBox(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetClipCursor(LPRECT a0)
{
    _PrintEnter("GetClipCursor(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_GetClipCursor(a0);
    } __finally {
        _PrintExit("GetClipCursor() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetClipRgn(HDC a0,
                              HRGN a1)
{
    _PrintEnter("GetClipRgn(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_GetClipRgn(a0, a1);
    } __finally {
        _PrintExit("GetClipRgn(,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_GetClipboardData(UINT a0)
{
    _PrintEnter("GetClipboardData(%lx)\n", a0);

    HANDLE rv = 0;
    __try {
        rv = Real_GetClipboardData(a0);
    } __finally {
        _PrintExit("GetClipboardData() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetClipboardFormatNameA(UINT a0,
                                           LPSTR a1,
                                           int a2)
{
    _PrintEnter("GetClipboardFormatNameA(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetClipboardFormatNameA(a0, a1, a2);
    } __finally {
        _PrintExit("GetClipboardFormatNameA(,%hs,) -> %lx\n", a1, rv);
    };
    return rv;
}

int __stdcall Mine_GetClipboardFormatNameW(UINT a0,
                                           LPWSTR a1,
                                           int a2)
{
    _PrintEnter("GetClipboardFormatNameW(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetClipboardFormatNameW(a0, a1, a2);
    } __finally {
        _PrintExit("GetClipboardFormatNameW(,%ls,) -> %lx\n", a1, rv);
    };
    return rv;
}

HWND __stdcall Mine_GetClipboardOwner(void)
{
    _PrintEnter("GetClipboardOwner()\n");

    HWND rv = 0;
    __try {
        rv = Real_GetClipboardOwner();
    } __finally {
        _PrintExit("GetClipboardOwner() -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetClipboardViewer(void)
{
    _PrintEnter("GetClipboardViewer()\n");

    HWND rv = 0;
    __try {
        rv = Real_GetClipboardViewer();
    } __finally {
        _PrintExit("GetClipboardViewer() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetColorAdjustment(HDC a0,
                                       LPCOLORADJUSTMENT a1)
{
    _PrintEnter("GetColorAdjustment(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetColorAdjustment(a0, a1);
    } __finally {
        _PrintExit("GetColorAdjustment(,) -> %lx\n", rv);
    };
    return rv;
}

HCOLORSPACE __stdcall Mine_GetColorSpace(HDC a0)
{
    _PrintEnter("GetColorSpace(%lx)\n", a0);

    HCOLORSPACE rv = 0;
    __try {
        rv = Real_GetColorSpace(a0);
    } __finally {
        _PrintExit("GetColorSpace() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCommConfig(HANDLE a0,
                                  LPCOMMCONFIG a1,
                                  LPDWORD a2)
{
    _PrintEnter("GetCommConfig(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetCommConfig(a0, a1, a2);
    } __finally {
        _PrintExit("GetCommConfig(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCommMask(HANDLE a0,
                                LPDWORD a1)
{
    _PrintEnter("GetCommMask(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetCommMask(a0, a1);
    } __finally {
        _PrintExit("GetCommMask(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCommModemStatus(HANDLE a0,
                                       LPDWORD a1)
{
    _PrintEnter("GetCommModemStatus(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetCommModemStatus(a0, a1);
    } __finally {
        _PrintExit("GetCommModemStatus(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCommProperties(HANDLE a0,
                                      LPCOMMPROP a1)
{
    _PrintEnter("GetCommProperties(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetCommProperties(a0, a1);
    } __finally {
        _PrintExit("GetCommProperties(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCommState(HANDLE a0,
                                 struct _DCB* a1)
{
    _PrintEnter("GetCommState(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetCommState(a0, a1);
    } __finally {
        _PrintExit("GetCommState(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCommTimeouts(HANDLE a0,
                                    struct _COMMTIMEOUTS* a1)
{
    _PrintEnter("GetCommTimeouts(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetCommTimeouts(a0, a1);
    } __finally {
        _PrintExit("GetCommTimeouts(,) -> %lx\n", rv);
    };
    return rv;
}

LPSTR __stdcall Mine_GetCommandLineA(void)
{
    _PrintEnter("GetCommandLineA()\n");

    LPSTR rv = 0;
    __try {
        rv = Real_GetCommandLineA();
    } __finally {
        _PrintExit("GetCommandLineA() -> %hs\n", rv);
    };
    return rv;
}

LPWSTR __stdcall Mine_GetCommandLineW(void)
{
    _PrintEnter("GetCommandLineW()\n");

    LPWSTR rv = 0;
    __try {
        rv = Real_GetCommandLineW();
    } __finally {
        _PrintExit("GetCommandLineW() -> %ls\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetCompressedFileSizeA(LPCSTR a0,
                                            LPDWORD a1)
{
    _PrintEnter("GetCompressedFileSizeA(%hs,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetCompressedFileSizeA(a0, a1);
    } __finally {
        _PrintExit("GetCompressedFileSizeA(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetCompressedFileSizeW(LPCWSTR a0,
                                            LPDWORD a1)
{
    _PrintEnter("GetCompressedFileSizeW(%ls,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetCompressedFileSizeW(a0, a1);
    } __finally {
        _PrintExit("GetCompressedFileSizeW(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetComputerNameA(LPSTR a0,
                                     LPDWORD a1)
{
    _PrintEnter("GetComputerNameA(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetComputerNameA(a0, a1);
    } __finally {
        _PrintExit("GetComputerNameA(%hs,) -> %lx\n", a0, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetComputerNameW(LPWSTR a0,
                                     LPDWORD a1)
{
    _PrintEnter("GetComputerNameW(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetComputerNameW(a0, a1);
    } __finally {
        _PrintExit("GetComputerNameW(%ls,) -> %lx\n", a0, rv);
    };
    return rv;
}

UINT __stdcall Mine_GetConsoleCP(void)
{
    _PrintEnter("GetConsoleCP()\n");

    UINT rv = 0;
    __try {
        rv = Real_GetConsoleCP();
    } __finally {
        _PrintExit("GetConsoleCP() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetConsoleCursorInfo(HANDLE a0,
                                         PCONSOLE_CURSOR_INFO a1)
{
    _PrintEnter("GetConsoleCursorInfo(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetConsoleCursorInfo(a0, a1);
    } __finally {
        _PrintExit("GetConsoleCursorInfo(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetConsoleMode(HANDLE a0,
                                   LPDWORD a1)
{
    _PrintEnter("GetConsoleMode(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetConsoleMode(a0, a1);
    } __finally {
        _PrintExit("GetConsoleMode(,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetConsoleOutputCP(void)
{
    _PrintEnter("GetConsoleOutputCP()\n");

    UINT rv = 0;
    __try {
        rv = Real_GetConsoleOutputCP();
    } __finally {
        _PrintExit("GetConsoleOutputCP() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetConsoleScreenBufferInfo(HANDLE a0,
                                               PCONSOLE_SCREEN_BUFFER_INFO a1)
{
    _PrintEnter("GetConsoleScreenBufferInfo(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetConsoleScreenBufferInfo(a0, a1);
    } __finally {
        _PrintExit("GetConsoleScreenBufferInfo(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetConsoleTitleA(LPSTR a0,
                                      DWORD a1)
{
    _PrintEnter("GetConsoleTitleA(%lx,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetConsoleTitleA(a0, a1);
    } __finally {
        _PrintExit("GetConsoleTitleA(%hs,) -> %lx\n", a0, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetConsoleTitleW(LPWSTR a0,
                                      DWORD a1)
{
    _PrintEnter("GetConsoleTitleW(%lx,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetConsoleTitleW(a0, a1);
    } __finally {
        _PrintExit("GetConsoleTitleW(%ls,) -> %lx\n", a0, rv);
    };
    return rv;
}

HRESULT __stdcall Mine_GetConvertStg(struct IStorage* a0)
{
    _PrintEnter("GetConvertStg(%lx)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_GetConvertStg(a0);
    } __finally {
        _PrintExit("GetConvertStg() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetCurrencyFormatA(LCID a0,
                                      DWORD a1,
                                      LPCSTR a2,
                                      struct _currencyfmtA* a3,
                                      LPSTR a4,
                                      int a5)
{
    _PrintEnter("GetCurrencyFormatA(%lx,%lx,%hs,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_GetCurrencyFormatA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("GetCurrencyFormatA(,,,,%hs,) -> %lx\n", a4, rv);
    };
    return rv;
}

int __stdcall Mine_GetCurrencyFormatW(LCID a0,
                                      DWORD a1,
                                      LPCWSTR a2,
                                      struct _currencyfmtW* a3,
                                      LPWSTR a4,
                                      int a5)
{
    _PrintEnter("GetCurrencyFormatW(%lx,%lx,%ls,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_GetCurrencyFormatW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("GetCurrencyFormatW(,,,,%ls,) -> %lx\n", a4, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetCurrentDirectoryA(DWORD a0,
                                          LPSTR a1)
{
    _PrintEnter("GetCurrentDirectoryA(%lx,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetCurrentDirectoryA(a0, a1);
    } __finally {
        _PrintExit("GetCurrentDirectoryA(,%hs) -> %lx\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetCurrentDirectoryW(DWORD a0,
                                          LPWSTR a1)
{
    _PrintEnter("GetCurrentDirectoryW(%lx,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetCurrentDirectoryW(a0, a1);
    } __finally {
        _PrintExit("GetCurrentDirectoryW(,%ls) -> %lx\n", a1, rv);
    };
    return rv;
}

HGDIOBJ __stdcall Mine_GetCurrentObject(HDC a0,
                                        UINT a1)
{
    _PrintEnter("GetCurrentObject(%lx,%lx)\n", a0, a1);

    HGDIOBJ rv = 0;
    __try {
        rv = Real_GetCurrentObject(a0, a1);
    } __finally {
        _PrintExit("GetCurrentObject(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCurrentPositionEx(HDC a0,
                                         struct tagPOINT* a1)
{
    _PrintEnter("GetCurrentPositionEx(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetCurrentPositionEx(a0, a1);
    } __finally {
        _PrintExit("GetCurrentPositionEx(,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_GetCurrentProcess(void)
{
    _PrintEnter("GetCurrentProcess()\n");

    HANDLE rv = 0;
    __try {
        rv = Real_GetCurrentProcess();
    } __finally {
        _PrintExit("GetCurrentProcess() -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetCurrentProcessId(void)
{
    _PrintEnter("GetCurrentProcessId()\n");

    DWORD rv = 0;
    __try {
        rv = Real_GetCurrentProcessId();
    } __finally {
        _PrintExit("GetCurrentProcessId() -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetCurrentThreadId(void)
{
    _PrintEnter("GetCurrentThreadId()\n");

    DWORD rv = 0;
    __try {
        rv = Real_GetCurrentThreadId();
    } __finally {
        _PrintExit("GetCurrentThreadId() -> %lx\n", rv);
    };
    return rv;
}

HCURSOR __stdcall Mine_GetCursor(void)
{
    _PrintEnter("GetCursor()\n");

    HCURSOR rv = 0;
    __try {
        rv = Real_GetCursor();
    } __finally {
        _PrintExit("GetCursor() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetCursorPos(struct tagPOINT* a0)
{
    _PrintEnter("GetCursorPos(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_GetCursorPos(a0);
    } __finally {
        _PrintExit("GetCursorPos() -> %lx\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_GetDC(HWND a0)
{
    _PrintEnter("GetDC(%lx)\n", a0);

    HDC rv = 0;
    __try {
        rv = Real_GetDC(a0);
    } __finally {
        _PrintExit("GetDC() -> %lx\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_GetDCEx(HWND a0,
                           HRGN a1,
                           DWORD a2)
{
    _PrintEnter("GetDCEx(%lx,%lx,%lx)\n", a0, a1, a2);

    HDC rv = 0;
    __try {
        rv = Real_GetDCEx(a0, a1, a2);
    } __finally {
        _PrintExit("GetDCEx(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetDCOrgEx(HDC a0,
                               struct tagPOINT* a1)
{
    _PrintEnter("GetDCOrgEx(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetDCOrgEx(a0, a1);
    } __finally {
        _PrintExit("GetDCOrgEx(,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetDIBColorTable(HDC a0,
                                     UINT a1,
                                     UINT a2,
                                     RGBQUAD* a3)
{
    _PrintEnter("GetDIBColorTable(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    UINT rv = 0;
    __try {
        rv = Real_GetDIBColorTable(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetDIBColorTable(,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetDIBits(HDC a0,
                             HBITMAP a1,
                             UINT a2,
                             UINT a3,
                             LPVOID a4,
                             LPBITMAPINFO a5,
                             UINT a6)
{
    _PrintEnter("GetDIBits(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    int rv = 0;
    __try {
        rv = Real_GetDIBits(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("GetDIBits(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetDateFormatA(LCID a0,
                                  DWORD a1,
                                  SYSTEMTIME* a2,
                                  LPCSTR a3,
                                  LPSTR a4,
                                  int a5)
{
    _PrintEnter("GetDateFormatA(%lx,%lx,%lx,%hs,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_GetDateFormatA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("GetDateFormatA(,,,,%hs,) -> %lx\n", a4, rv);
    };
    return rv;
}

int __stdcall Mine_GetDateFormatW(LCID a0,
                                  DWORD a1,
                                  SYSTEMTIME* a2,
                                  LPCWSTR a3,
                                  LPWSTR a4,
                                  int a5)
{
    _PrintEnter("GetDateFormatW(%lx,%lx,%lx,%ls,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_GetDateFormatW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("GetDateFormatW(,,,,%ls,) -> %lx\n", a4, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetDefaultCommConfigA(LPCSTR a0,
                                          LPCOMMCONFIG a1,
                                          LPDWORD a2)
{
    _PrintEnter("GetDefaultCommConfigA(%hs,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetDefaultCommConfigA(a0, a1, a2);
    } __finally {
        _PrintExit("GetDefaultCommConfigA(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetDefaultCommConfigW(LPCWSTR a0,
                                          LPCOMMCONFIG a1,
                                          LPDWORD a2)
{
    _PrintEnter("GetDefaultCommConfigW(%ls,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetDefaultCommConfigW(a0, a1, a2);
    } __finally {
        _PrintExit("GetDefaultCommConfigW(,,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetDesktopWindow(void)
{
    _PrintEnter("GetDesktopWindow()\n");

    HWND rv = 0;
    __try {
        rv = Real_GetDesktopWindow();
    } __finally {
        _PrintExit("GetDesktopWindow() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetDeviceCaps(HDC a0,
                                 int a1)
{
    _PrintEnter("GetDeviceCaps(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_GetDeviceCaps(a0, a1);
    } __finally {
        _PrintExit("GetDeviceCaps(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetDeviceGammaRamp(HDC a0,
                                       LPVOID a1)
{
    _PrintEnter("GetDeviceGammaRamp(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetDeviceGammaRamp(a0, a1);
    } __finally {
        _PrintExit("GetDeviceGammaRamp(,) -> %lx\n", rv);
    };
    return rv;
}

long __stdcall Mine_GetDialogBaseUnits(void)
{
    _PrintEnter("GetDialogBaseUnits()\n");

    long rv = 0;
    __try {
        rv = Real_GetDialogBaseUnits();
    } __finally {
        _PrintExit("GetDialogBaseUnits() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetDiskFreeSpaceA(LPCSTR a0,
                                      LPDWORD a1,
                                      LPDWORD a2,
                                      LPDWORD a3,
                                      LPDWORD a4)
{
    _PrintEnter("GetDiskFreeSpaceA(%hs,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_GetDiskFreeSpaceA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetDiskFreeSpaceA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetDiskFreeSpaceExA(LPCSTR a0,
                                        union _ULARGE_INTEGER* a1,
                                        union _ULARGE_INTEGER* a2,
                                        union _ULARGE_INTEGER* a3)
{
    _PrintEnter("GetDiskFreeSpaceExA(%hs,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetDiskFreeSpaceExA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetDiskFreeSpaceExA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetDiskFreeSpaceExW(LPCWSTR a0,
                                        union _ULARGE_INTEGER* a1,
                                        union _ULARGE_INTEGER* a2,
                                        union _ULARGE_INTEGER* a3)
{
    _PrintEnter("GetDiskFreeSpaceExW(%ls,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetDiskFreeSpaceExW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetDiskFreeSpaceExW(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetDiskFreeSpaceW(LPCWSTR a0,
                                      LPDWORD a1,
                                      LPDWORD a2,
                                      LPDWORD a3,
                                      LPDWORD a4)
{
    _PrintEnter("GetDiskFreeSpaceW(%ls,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_GetDiskFreeSpaceW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetDiskFreeSpaceW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetDlgCtrlID(HWND a0)
{
    _PrintEnter("GetDlgCtrlID(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetDlgCtrlID(a0);
    } __finally {
        _PrintExit("GetDlgCtrlID() -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetDlgItem(HWND a0,
                               int a1)
{
    _PrintEnter("GetDlgItem(%lx,%lx)\n", a0, a1);

    HWND rv = 0;
    __try {
        rv = Real_GetDlgItem(a0, a1);
    } __finally {
        _PrintExit("GetDlgItem(,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetDlgItemInt(HWND a0,
                                  int a1,
                                  BOOL* a2,
                                  BOOL a3)
{
    _PrintEnter("GetDlgItemInt(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    UINT rv = 0;
    __try {
        rv = Real_GetDlgItemInt(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetDlgItemInt(,,,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetDlgItemTextA(HWND a0,
                                    int a1,
                                    LPSTR a2,
                                    int a3)
{
    _PrintEnter("GetDlgItemTextA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    UINT rv = 0;
    __try {
        rv = Real_GetDlgItemTextA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetDlgItemTextA(,,%hs,) -> %lx\n", a2, rv);
    };
    return rv;
}

UINT __stdcall Mine_GetDlgItemTextW(HWND a0,
                                    int a1,
                                    LPWSTR a2,
                                    int a3)
{
    _PrintEnter("GetDlgItemTextW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    UINT rv = 0;
    __try {
        rv = Real_GetDlgItemTextW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetDlgItemTextW(,,%ls,) -> %lx\n", a2, rv);
    };
    return rv;
}

UINT __stdcall Mine_GetDoubleClickTime(void)
{
    _PrintEnter("GetDoubleClickTime()\n");

    UINT rv = 0;
    __try {
        rv = Real_GetDoubleClickTime();
    } __finally {
        _PrintExit("GetDoubleClickTime() -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetDriveTypeA(LPCSTR a0)
{
    _PrintEnter("GetDriveTypeA(%hs)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_GetDriveTypeA(a0);
    } __finally {
        _PrintExit("GetDriveTypeA() -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetDriveTypeW(LPCWSTR a0)
{
    _PrintEnter("GetDriveTypeW(%ls)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_GetDriveTypeW(a0);
    } __finally {
        _PrintExit("GetDriveTypeW() -> %lx\n", rv);
    };
    return rv;
}

HENHMETAFILE __stdcall Mine_GetEnhMetaFileA(LPCSTR a0)
{
    _PrintEnter("GetEnhMetaFileA(%hs)\n", a0);

    HENHMETAFILE rv = 0;
    __try {
        rv = Real_GetEnhMetaFileA(a0);
    } __finally {
        _PrintExit("GetEnhMetaFileA() -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetEnhMetaFileBits(HENHMETAFILE a0,
                                       UINT a1,
                                       LPBYTE a2)
{
    _PrintEnter("GetEnhMetaFileBits(%lx,%lx,%lx)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetEnhMetaFileBits(a0, a1, a2);
    } __finally {
        _PrintExit("GetEnhMetaFileBits(,,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetEnhMetaFileDescriptionA(HENHMETAFILE a0,
                                               UINT a1,
                                               LPSTR a2)
{
    _PrintEnter("GetEnhMetaFileDescriptionA(%lx,%lx,%lx)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetEnhMetaFileDescriptionA(a0, a1, a2);
    } __finally {
        _PrintExit("GetEnhMetaFileDescriptionA(,,%hs) -> %lx\n", a2, rv);
    };
    return rv;
}

UINT __stdcall Mine_GetEnhMetaFileDescriptionW(HENHMETAFILE a0,
                                               UINT a1,
                                               LPWSTR a2)
{
    _PrintEnter("GetEnhMetaFileDescriptionW(%lx,%lx,%lx)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetEnhMetaFileDescriptionW(a0, a1, a2);
    } __finally {
        _PrintExit("GetEnhMetaFileDescriptionW(,,%ls) -> %lx\n", a2, rv);
    };
    return rv;
}

UINT __stdcall Mine_GetEnhMetaFileHeader(HENHMETAFILE a0,
                                         UINT a1,
                                         struct tagENHMETAHEADER* a2)
{
    _PrintEnter("GetEnhMetaFileHeader(%lx,%lx,%lx)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetEnhMetaFileHeader(a0, a1, a2);
    } __finally {
        _PrintExit("GetEnhMetaFileHeader(,,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetEnhMetaFilePaletteEntries(HENHMETAFILE a0,
                                                 UINT a1,
                                                 struct tagPALETTEENTRY* a2)
{
    _PrintEnter("GetEnhMetaFilePaletteEntries(%lx,%lx,%lx)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetEnhMetaFilePaletteEntries(a0, a1, a2);
    } __finally {
        _PrintExit("GetEnhMetaFilePaletteEntries(,,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetEnhMetaFilePixelFormat(HENHMETAFILE a0,
                                              UINT a1,
                                              PIXELFORMATDESCRIPTOR* a2)
{
    _PrintEnter("GetEnhMetaFilePixelFormat(%lx,%lx,%lx)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetEnhMetaFilePixelFormat(a0, a1, a2);
    } __finally {
        _PrintExit("GetEnhMetaFilePixelFormat(,,) -> %lx\n", rv);
    };
    return rv;
}

HENHMETAFILE __stdcall Mine_GetEnhMetaFileW(LPCWSTR a0)
{
    _PrintEnter("GetEnhMetaFileW(%ls)\n", a0);

    HENHMETAFILE rv = 0;
    __try {
        rv = Real_GetEnhMetaFileW(a0);
    } __finally {
        _PrintExit("GetEnhMetaFileW() -> %lx\n", rv);
    };
    return rv;
}

LPSTR __stdcall Mine_GetEnvironmentStrings(void)
{
    _PrintEnter("GetEnvironmentStrings()\n");

    LPSTR rv = 0;
    __try {
        rv = Real_GetEnvironmentStrings();
    } __finally {
        _PrintExit("GetEnvironmentStrings() -> %hs\n", rv);
    };
    return rv;
}

LPWSTR __stdcall Mine_GetEnvironmentStringsW(void)
{
    _PrintEnter("GetEnvironmentStringsW()\n");

    LPWSTR rv = 0;
    __try {
        rv = Real_GetEnvironmentStringsW();
    } __finally {
        _PrintExit("GetEnvironmentStringsW() -> %ls\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetEnvironmentVariableA(LPCSTR a0,
                                             LPSTR a1,
                                             DWORD a2)
{
    _PrintEnter("GetEnvironmentVariableA(%hs,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetEnvironmentVariableA(a0, a1, a2);
    } __finally {
        _PrintExit("GetEnvironmentVariableA(,%hs,) -> %lx\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetEnvironmentVariableW(LPCWSTR a0,
                                             LPWSTR a1,
                                             DWORD a2)
{
    _PrintEnter("GetEnvironmentVariableW(%ls,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetEnvironmentVariableW(a0, a1, a2);
    } __finally {
        _PrintExit("GetEnvironmentVariableW(,%ls,) -> %lx\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetExitCodeProcess(HANDLE a0,
                                       LPDWORD a1)
{
    _PrintEnter("GetExitCodeProcess(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetExitCodeProcess(a0, a1);
    } __finally {
        _PrintExit("GetExitCodeProcess(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetExitCodeThread(HANDLE a0,
                                      LPDWORD a1)
{
    _PrintEnter("GetExitCodeThread(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetExitCodeThread(a0, a1);
    } __finally {
        _PrintExit("GetExitCodeThread(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetFileAttributesA(LPCSTR a0)
{
    _PrintEnter("GetFileAttributesA(%hs)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetFileAttributesA(a0);
    } __finally {
        _PrintExit("GetFileAttributesA() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetFileAttributesExA(LPCSTR a0,
                                         enum _GET_FILEEX_INFO_LEVELS a1,
                                         LPVOID a2)
{
    _PrintEnter("GetFileAttributesExA(%hs,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetFileAttributesExA(a0, a1, a2);
    } __finally {
        _PrintExit("GetFileAttributesExA(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetFileAttributesExW(LPCWSTR a0,
                                         enum _GET_FILEEX_INFO_LEVELS a1,
                                         LPVOID a2)
{
    _PrintEnter("GetFileAttributesExW(%ls,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetFileAttributesExW(a0, a1, a2);
    } __finally {
        _PrintExit("GetFileAttributesExW(,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetFileAttributesW(LPCWSTR a0)
{
    _PrintEnter("GetFileAttributesW(%ls)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetFileAttributesW(a0);
    } __finally {
        _PrintExit("GetFileAttributesW() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetFileInformationByHandle(HANDLE a0,
                                               struct _BY_HANDLE_FILE_INFORMATION* a1)
{
    _PrintEnter("GetFileInformationByHandle(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetFileInformationByHandle(a0, a1);
    } __finally {
        _PrintExit("GetFileInformationByHandle(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetFileSize(HANDLE a0,
                                 LPDWORD a1)
{
    _PrintEnter("GetFileSize(%lx,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetFileSize(a0, a1);
    } __finally {
        _PrintExit("GetFileSize(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetFileTime(HANDLE a0,
                                LPFILETIME a1,
                                LPFILETIME a2,
                                LPFILETIME a3)
{
    _PrintEnter("GetFileTime(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetFileTime(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetFileTime(,,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetFileType(HANDLE a0)
{
    _PrintEnter("GetFileType(%lx)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetFileType(a0);
    } __finally {
        _PrintExit("GetFileType() -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetFocus(void)
{
    _PrintEnter("GetFocus()\n");

    HWND rv = 0;
    __try {
        rv = Real_GetFocus();
    } __finally {
        _PrintExit("GetFocus() -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetFontData(HDC a0,
                                 DWORD a1,
                                 DWORD a2,
                                 LPVOID a3,
                                 DWORD a4)
{
    _PrintEnter("GetFontData(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_GetFontData(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetFontData(,,,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetFontLanguageInfo(HDC a0)
{
    _PrintEnter("GetFontLanguageInfo(%lx)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetFontLanguageInfo(a0);
    } __finally {
        _PrintExit("GetFontLanguageInfo() -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetForegroundWindow(void)
{
    _PrintEnter("GetForegroundWindow()\n");

    HWND rv = 0;
    __try {
        rv = Real_GetForegroundWindow();
    } __finally {
        _PrintExit("GetForegroundWindow() -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetFullPathNameA(LPCSTR a0,
                                      DWORD a1,
                                      LPSTR a2,
                                      LPSTR* a3)
{
    _PrintEnter("GetFullPathNameA(%hs,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    DWORD rv = 0;
    __try {
        rv = Real_GetFullPathNameA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetFullPathNameA(,,%hs,) -> %lx\n", a2, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetFullPathNameW(LPCWSTR a0,
                                      DWORD a1,
                                      LPWSTR a2,
                                      LPWSTR* a3)
{
    _PrintEnter("GetFullPathNameW(%ls,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    DWORD rv = 0;
    __try {
        rv = Real_GetFullPathNameW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetFullPathNameW(,,%ls,) -> %lx\n", a2, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetGlyphOutlineA(HDC a0,
                                      UINT a1,
                                      UINT a2,
                                      LPGLYPHMETRICS a3,
                                      DWORD a4,
                                      LPVOID a5,
                                      MAT2* a6)
{
    _PrintEnter("GetGlyphOutlineA(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    DWORD rv = 0;
    __try {
        rv = Real_GetGlyphOutlineA(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("GetGlyphOutlineA(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetGlyphOutlineW(HDC a0,
                                      UINT a1,
                                      UINT a2,
                                      LPGLYPHMETRICS a3,
                                      DWORD a4,
                                      LPVOID a5,
                                      MAT2* a6)
{
    _PrintEnter("GetGlyphOutlineW(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    DWORD rv = 0;
    __try {
        rv = Real_GetGlyphOutlineW(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("GetGlyphOutlineW(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetGraphicsMode(HDC a0)
{
    _PrintEnter("GetGraphicsMode(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetGraphicsMode(a0);
    } __finally {
        _PrintExit("GetGraphicsMode() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_GetHGlobalFromILockBytes(struct ILockBytes* a0,
                                                HGLOBAL* a1)
{
    _PrintEnter("GetHGlobalFromILockBytes(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_GetHGlobalFromILockBytes(a0, a1);
    } __finally {
        _PrintExit("GetHGlobalFromILockBytes(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_GetHGlobalFromStream(LPSTREAM a0,
                                            HGLOBAL* a1)
{
    _PrintEnter("GetHGlobalFromStream(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_GetHGlobalFromStream(a0, a1);
    } __finally {
        _PrintExit("GetHGlobalFromStream(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetHandleInformation(HANDLE a0,
                                         LPDWORD a1)
{
    _PrintEnter("GetHandleInformation(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetHandleInformation(a0, a1);
    } __finally {
        _PrintExit("GetHandleInformation(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetICMProfileA(HDC a0,
                                   LPDWORD a1,
                                   LPSTR a2)
{
    _PrintEnter("GetICMProfileA(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetICMProfileA(a0, a1, a2);
    } __finally {
        _PrintExit("GetICMProfileA(,,%hs) -> %lx\n", a2, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetICMProfileW(HDC a0,
                                   LPDWORD a1,
                                   LPWSTR a2)
{
    _PrintEnter("GetICMProfileW(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetICMProfileW(a0, a1, a2);
    } __finally {
        _PrintExit("GetICMProfileW(,,%ls) -> %lx\n", a2, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetIconInfo(HICON a0,
                                struct _ICONINFO* a1)
{
    _PrintEnter("GetIconInfo(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetIconInfo(a0, a1);
    } __finally {
        _PrintExit("GetIconInfo(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetInputState(void)
{
    _PrintEnter("GetInputState()\n");

    BOOL rv = 0;
    __try {
        rv = Real_GetInputState();
    } __finally {
        _PrintExit("GetInputState() -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetKBCodePage(void)
{
    _PrintEnter("GetKBCodePage()\n");

    UINT rv = 0;
    __try {
        rv = Real_GetKBCodePage();
    } __finally {
        _PrintExit("GetKBCodePage() -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetKerningPairsA(HDC a0,
                                      DWORD a1,
                                      struct tagKERNINGPAIR* a2)
{
    _PrintEnter("GetKerningPairsA(%lx,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetKerningPairsA(a0, a1, a2);
    } __finally {
        _PrintExit("GetKerningPairsA(,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetKerningPairsW(HDC a0,
                                      DWORD a1,
                                      struct tagKERNINGPAIR* a2)
{
    _PrintEnter("GetKerningPairsW(%lx,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetKerningPairsW(a0, a1, a2);
    } __finally {
        _PrintExit("GetKerningPairsW(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetKeyNameTextA(LONG a0,
                                   LPSTR a1,
                                   int a2)
{
    _PrintEnter("GetKeyNameTextA(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetKeyNameTextA(a0, a1, a2);
    } __finally {
        _PrintExit("GetKeyNameTextA(,%hs,) -> %lx\n", a1, rv);
    };
    return rv;
}

int __stdcall Mine_GetKeyNameTextW(LONG a0,
                                   LPWSTR a1,
                                   int a2)
{
    _PrintEnter("GetKeyNameTextW(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetKeyNameTextW(a0, a1, a2);
    } __finally {
        _PrintExit("GetKeyNameTextW(,%ls,) -> %lx\n", a1, rv);
    };
    return rv;
}

SHORT __stdcall Mine_GetKeyState(int a0)
{
    _PrintEnter("GetKeyState(%lx)\n", a0);

    SHORT rv = 0;
    __try {
        rv = Real_GetKeyState(a0);
    } __finally {
        _PrintExit("GetKeyState() -> %lx\n", rv);
    };
    return rv;
}

HKL __stdcall Mine_GetKeyboardLayout(DWORD a0)
{
    _PrintEnter("GetKeyboardLayout(%lx)\n", a0);

    HKL rv = 0;
    __try {
        rv = Real_GetKeyboardLayout(a0);
    } __finally {
        _PrintExit("GetKeyboardLayout() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetKeyboardLayoutList(int a0,
                                         HKL* a1)
{
    _PrintEnter("GetKeyboardLayoutList(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_GetKeyboardLayoutList(a0, a1);
    } __finally {
        _PrintExit("GetKeyboardLayoutList(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetKeyboardLayoutNameA(LPSTR a0)
{
    _PrintEnter("GetKeyboardLayoutNameA(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_GetKeyboardLayoutNameA(a0);
    } __finally {
        _PrintExit("GetKeyboardLayoutNameA(%hs) -> %lx\n", a0, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetKeyboardLayoutNameW(LPWSTR a0)
{
    _PrintEnter("GetKeyboardLayoutNameW(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_GetKeyboardLayoutNameW(a0);
    } __finally {
        _PrintExit("GetKeyboardLayoutNameW(%ls) -> %lx\n", a0, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetKeyboardState(PBYTE a0)
{
    _PrintEnter("GetKeyboardState(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_GetKeyboardState(a0);
    } __finally {
        _PrintExit("GetKeyboardState() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetKeyboardType(int a0)
{
    _PrintEnter("GetKeyboardType(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetKeyboardType(a0);
    } __finally {
        _PrintExit("GetKeyboardType() -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetLastActivePopup(HWND a0)
{
    _PrintEnter("GetLastActivePopup(%lx)\n", a0);

    HWND rv = 0;
    __try {
        rv = Real_GetLastActivePopup(a0);
    } __finally {
        _PrintExit("GetLastActivePopup() -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_GetLocalTime(struct _SYSTEMTIME* a0)
{
    _PrintEnter("GetLocalTime(%lx)\n", a0);

    __try {
        Real_GetLocalTime(a0);
    } __finally {
        _PrintExit("GetLocalTime() ->\n");
    };
}

int __stdcall Mine_GetLocaleInfoA(LCID a0,
                                  LCTYPE a1,
                                  LPSTR a2,
                                  int a3)
{
    _PrintEnter("GetLocaleInfoA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_GetLocaleInfoA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetLocaleInfoA(,,%hs,) -> %lx\n", a2, rv);
    };
    return rv;
}

int __stdcall Mine_GetLocaleInfoW(LCID a0,
                                  LCTYPE a1,
                                  LPWSTR a2,
                                  int a3)
{
    _PrintEnter("GetLocaleInfoW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_GetLocaleInfoW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetLocaleInfoW(,,%ls,) -> %lx\n", a2, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetLogColorSpaceA(HCOLORSPACE a0,
                                      struct tagLOGCOLORSPACEA* a1,
                                      DWORD a2)
{
    _PrintEnter("GetLogColorSpaceA(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetLogColorSpaceA(a0, a1, a2);
    } __finally {
        _PrintExit("GetLogColorSpaceA(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetLogColorSpaceW(HCOLORSPACE a0,
                                      struct tagLOGCOLORSPACEW* a1,
                                      DWORD a2)
{
    _PrintEnter("GetLogColorSpaceW(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetLogColorSpaceW(a0, a1, a2);
    } __finally {
        _PrintExit("GetLogColorSpaceW(,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetLogicalDriveStringsA(DWORD a0,
                                             LPSTR a1)
{
    _PrintEnter("GetLogicalDriveStringsA(%lx,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetLogicalDriveStringsA(a0, a1);
    } __finally {
        _PrintExit("GetLogicalDriveStringsA(,%hs) -> %lx\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetLogicalDriveStringsW(DWORD a0,
                                             LPWSTR a1)
{
    _PrintEnter("GetLogicalDriveStringsW(%lx,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetLogicalDriveStringsW(a0, a1);
    } __finally {
        _PrintExit("GetLogicalDriveStringsW(,%ls) -> %lx\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetLogicalDrives(void)
{
    _PrintEnter("GetLogicalDrives()\n");

    DWORD rv = 0;
    __try {
        rv = Real_GetLogicalDrives();
    } __finally {
        _PrintExit("GetLogicalDrives() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetMailslotInfo(HANDLE a0,
                                    LPDWORD a1,
                                    LPDWORD a2,
                                    LPDWORD a3,
                                    LPDWORD a4)
{
    _PrintEnter("GetMailslotInfo(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_GetMailslotInfo(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetMailslotInfo(,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetMapMode(HDC a0)
{
    _PrintEnter("GetMapMode(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetMapMode(a0);
    } __finally {
        _PrintExit("GetMapMode() -> %lx\n", rv);
    };
    return rv;
}

HMENU __stdcall Mine_GetMenu(HWND a0)
{
    _PrintEnter("GetMenu(%lx)\n", a0);

    HMENU rv = 0;
    __try {
        rv = Real_GetMenu(a0);
    } __finally {
        _PrintExit("GetMenu() -> %lx\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_GetMenuCheckMarkDimensions(void)
{
    _PrintEnter("GetMenuCheckMarkDimensions()\n");

    LONG rv = 0;
    __try {
        rv = Real_GetMenuCheckMarkDimensions();
    } __finally {
        _PrintExit("GetMenuCheckMarkDimensions() -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetMenuContextHelpId(HMENU a0)
{
    _PrintEnter("GetMenuContextHelpId(%lx)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetMenuContextHelpId(a0);
    } __finally {
        _PrintExit("GetMenuContextHelpId() -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetMenuDefaultItem(HMENU a0,
                                       UINT a1,
                                       UINT a2)
{
    _PrintEnter("GetMenuDefaultItem(%lx,%lx,%lx)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetMenuDefaultItem(a0, a1, a2);
    } __finally {
        _PrintExit("GetMenuDefaultItem(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetMenuItemCount(HMENU a0)
{
    _PrintEnter("GetMenuItemCount(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetMenuItemCount(a0);
    } __finally {
        _PrintExit("GetMenuItemCount() -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetMenuItemID(HMENU a0,
                                  int a1)
{
    _PrintEnter("GetMenuItemID(%lx,%lx)\n", a0, a1);

    UINT rv = 0;
    __try {
        rv = Real_GetMenuItemID(a0, a1);
    } __finally {
        _PrintExit("GetMenuItemID(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetMenuItemInfoA(HMENU a0,
                                     UINT a1,
                                     BOOL a2,
                                     LPMENUITEMINFOA a3)
{
    _PrintEnter("GetMenuItemInfoA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetMenuItemInfoA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetMenuItemInfoA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetMenuItemInfoW(HMENU a0,
                                     UINT a1,
                                     BOOL a2,
                                     LPMENUITEMINFOW a3)
{
    _PrintEnter("GetMenuItemInfoW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetMenuItemInfoW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetMenuItemInfoW(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetMenuItemRect(HWND a0,
                                    HMENU a1,
                                    UINT a2,
                                    LPRECT a3)
{
    _PrintEnter("GetMenuItemRect(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetMenuItemRect(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetMenuItemRect(,,,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetMenuState(HMENU a0,
                                 UINT a1,
                                 UINT a2)
{
    _PrintEnter("GetMenuState(%lx,%lx,%lx)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetMenuState(a0, a1, a2);
    } __finally {
        _PrintExit("GetMenuState(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetMenuStringA(HMENU a0,
                                  UINT a1,
                                  LPSTR a2,
                                  int a3,
                                  UINT a4)
{
    _PrintEnter("GetMenuStringA(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_GetMenuStringA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetMenuStringA(,,%hs,,) -> %lx\n", a2, rv);
    };
    return rv;
}

int __stdcall Mine_GetMenuStringW(HMENU a0,
                                  UINT a1,
                                  LPWSTR a2,
                                  int a3,
                                  UINT a4)
{
    _PrintEnter("GetMenuStringW(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_GetMenuStringW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetMenuStringW(,,%ls,,) -> %lx\n", a2, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetMessageA(LPMSG a0,
                                HWND a1,
                                UINT a2,
                                UINT a3)
{
    _PrintEnter("GetMessageA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetMessageA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetMessageA(,,,) -> %lx\n", rv);
    };
    return rv;
}

LPARAM __stdcall Mine_GetMessageExtraInfo(void)
{
    _PrintEnter("GetMessageExtraInfo()\n");

    LPARAM rv = 0;
    __try {
        rv = Real_GetMessageExtraInfo();
    } __finally {
        _PrintExit("GetMessageExtraInfo() -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetMessagePos(void)
{
    _PrintEnter("GetMessagePos()\n");

    DWORD rv = 0;
    __try {
        rv = Real_GetMessagePos();
    } __finally {
        _PrintExit("GetMessagePos() -> %lx\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_GetMessageTime(void)
{
    _PrintEnter("GetMessageTime()\n");

    LONG rv = 0;
    __try {
        rv = Real_GetMessageTime();
    } __finally {
        _PrintExit("GetMessageTime() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetMessageW(LPMSG a0,
                                HWND a1,
                                UINT a2,
                                UINT a3)
{
    _PrintEnter("GetMessageW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetMessageW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetMessageW(,,,) -> %lx\n", rv);
    };
    return rv;
}

HMETAFILE __stdcall Mine_GetMetaFileA(LPCSTR a0)
{
    _PrintEnter("GetMetaFileA(%hs)\n", a0);

    HMETAFILE rv = 0;
    __try {
        rv = Real_GetMetaFileA(a0);
    } __finally {
        _PrintExit("GetMetaFileA() -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetMetaFileBitsEx(HMETAFILE a0,
                                      UINT a1,
                                      LPVOID a2)
{
    _PrintEnter("GetMetaFileBitsEx(%lx,%lx,%lx)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetMetaFileBitsEx(a0, a1, a2);
    } __finally {
        _PrintExit("GetMetaFileBitsEx(,,) -> %lx\n", rv);
    };
    return rv;
}

HMETAFILE __stdcall Mine_GetMetaFileW(LPCWSTR a0)
{
    _PrintEnter("GetMetaFileW(%ls)\n", a0);

    HMETAFILE rv = 0;
    __try {
        rv = Real_GetMetaFileW(a0);
    } __finally {
        _PrintExit("GetMetaFileW() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetMetaRgn(HDC a0,
                              HRGN a1)
{
    _PrintEnter("GetMetaRgn(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_GetMetaRgn(a0, a1);
    } __finally {
        _PrintExit("GetMetaRgn(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetMiterLimit(HDC a0,
                                  PFLOAT a1)
{
    _PrintEnter("GetMiterLimit(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetMiterLimit(a0, a1);
    } __finally {
        _PrintExit("GetMiterLimit(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetModuleFileNameA(HMODULE a0,
                                        LPSTR a1,
                                        DWORD a2)
{
    _PrintEnter("GetModuleFileNameA(%lx,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetModuleFileNameA(a0, a1, a2);
    } __finally {
        _PrintExit("GetModuleFileNameA(,%hs,) -> %lx\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetModuleFileNameW(HMODULE a0,
                                        LPWSTR a1,
                                        DWORD a2)
{
    _PrintEnter("GetModuleFileNameW(%lx,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetModuleFileNameW(a0, a1, a2);
    } __finally {
        _PrintExit("GetModuleFileNameW(,%ls,) -> %lx\n", a1, rv);
    };
    return rv;
}

HMODULE __stdcall Mine_GetModuleHandleA(LPCSTR a0)
{
    _PrintEnter("GetModuleHandleA(%hs)\n", a0);

    HMODULE rv = 0;
    __try {
        rv = Real_GetModuleHandleA(a0);
    } __finally {
        _PrintExit("GetModuleHandleA() -> %lx\n", rv);
    };
    return rv;
}

HMODULE __stdcall Mine_GetModuleHandleW(LPCWSTR a0)
{
    _PrintEnter("GetModuleHandleW(%ls)\n", a0);

    HMODULE rv = 0;
    __try {
        rv = Real_GetModuleHandleW(a0);
    } __finally {
        _PrintExit("GetModuleHandleW() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetNamedPipeHandleStateA(HANDLE a0,
                                             LPDWORD a1,
                                             LPDWORD a2,
                                             LPDWORD a3,
                                             LPDWORD a4,
                                             LPSTR a5,
                                             DWORD a6)
{
    _PrintEnter("GetNamedPipeHandleStateA(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_GetNamedPipeHandleStateA(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("GetNamedPipeHandleStateA(,,,,,%hs,) -> %lx\n", a5, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetNamedPipeHandleStateW(HANDLE a0,
                                             LPDWORD a1,
                                             LPDWORD a2,
                                             LPDWORD a3,
                                             LPDWORD a4,
                                             LPWSTR a5,
                                             DWORD a6)
{
    _PrintEnter("GetNamedPipeHandleStateW(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_GetNamedPipeHandleStateW(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("GetNamedPipeHandleStateW(,,,,,%ls,) -> %lx\n", a5, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetNamedPipeInfo(HANDLE a0,
                                     LPDWORD a1,
                                     LPDWORD a2,
                                     LPDWORD a3,
                                     LPDWORD a4)
{
    _PrintEnter("GetNamedPipeInfo(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_GetNamedPipeInfo(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetNamedPipeInfo(,,,,) -> %lx\n", rv);
    };
    return rv;
}

COLORREF __stdcall Mine_GetNearestColor(HDC a0,
                                        COLORREF a1)
{
    _PrintEnter("GetNearestColor(%lx,%lx)\n", a0, a1);

    COLORREF rv = 0;
    __try {
        rv = Real_GetNearestColor(a0, a1);
    } __finally {
        _PrintExit("GetNearestColor(,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetNearestPaletteIndex(HPALETTE a0,
                                           COLORREF a1)
{
    _PrintEnter("GetNearestPaletteIndex(%lx,%lx)\n", a0, a1);

    UINT rv = 0;
    __try {
        rv = Real_GetNearestPaletteIndex(a0, a1);
    } __finally {
        _PrintExit("GetNearestPaletteIndex(,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetNextDlgGroupItem(HWND a0,
                                        HWND a1,
                                        BOOL a2)
{
    _PrintEnter("GetNextDlgGroupItem(%lx,%lx,%lx)\n", a0, a1, a2);

    HWND rv = 0;
    __try {
        rv = Real_GetNextDlgGroupItem(a0, a1, a2);
    } __finally {
        _PrintExit("GetNextDlgGroupItem(,,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetNextDlgTabItem(HWND a0,
                                      HWND a1,
                                      BOOL a2)
{
    _PrintEnter("GetNextDlgTabItem(%lx,%lx,%lx)\n", a0, a1, a2);

    HWND rv = 0;
    __try {
        rv = Real_GetNextDlgTabItem(a0, a1, a2);
    } __finally {
        _PrintExit("GetNextDlgTabItem(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetNumberFormatA(LCID a0,
                                    DWORD a1,
                                    LPCSTR a2,
                                    NUMBERFMTA* a3,
                                    LPSTR a4,
                                    int a5)
{
    _PrintEnter("GetNumberFormatA(%lx,%lx,%hs,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_GetNumberFormatA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("GetNumberFormatA(,,,,%hs,) -> %lx\n", a4, rv);
    };
    return rv;
}

int __stdcall Mine_GetNumberFormatW(LCID a0,
                                    DWORD a1,
                                    LPCWSTR a2,
                                    NUMBERFMTW* a3,
                                    LPWSTR a4,
                                    int a5)
{
    _PrintEnter("GetNumberFormatW(%lx,%lx,%ls,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_GetNumberFormatW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("GetNumberFormatW(,,,,%ls,) -> %lx\n", a4, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetNumberOfConsoleInputEvents(HANDLE a0,
                                                  LPDWORD a1)
{
    _PrintEnter("GetNumberOfConsoleInputEvents(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetNumberOfConsoleInputEvents(a0, a1);
    } __finally {
        _PrintExit("GetNumberOfConsoleInputEvents(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetNumberOfConsoleMouseButtons(LPDWORD a0)
{
    _PrintEnter("GetNumberOfConsoleMouseButtons(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_GetNumberOfConsoleMouseButtons(a0);
    } __finally {
        _PrintExit("GetNumberOfConsoleMouseButtons() -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetOEMCP(void)
{
    _PrintEnter("GetOEMCP()\n");

    UINT rv = 0;
    __try {
        rv = Real_GetOEMCP();
    } __finally {
        _PrintExit("GetOEMCP() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetObjectA(HGDIOBJ a0,
                              int a1,
                              LPVOID a2)
{
    _PrintEnter("GetObjectA(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetObjectA(a0, a1, a2);
    } __finally {
        _PrintExit("GetObjectA(,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetObjectType(HGDIOBJ a0)
{
    _PrintEnter("GetObjectType(%lx)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetObjectType(a0);
    } __finally {
        _PrintExit("GetObjectType() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetObjectW(HGDIOBJ a0,
                              int a1,
                              LPVOID a2)
{
    _PrintEnter("GetObjectW(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetObjectW(a0, a1, a2);
    } __finally {
        _PrintExit("GetObjectW(,,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetOpenClipboardWindow(void)
{
    _PrintEnter("GetOpenClipboardWindow()\n");

    HWND rv = 0;
    __try {
        rv = Real_GetOpenClipboardWindow();
    } __finally {
        _PrintExit("GetOpenClipboardWindow() -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetOutlineTextMetricsA(HDC a0,
                                           UINT a1,
                                           LPOUTLINETEXTMETRICA a2)
{
    _PrintEnter("GetOutlineTextMetricsA(%lx,%lx,%lx)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetOutlineTextMetricsA(a0, a1, a2);
    } __finally {
        _PrintExit("GetOutlineTextMetricsA(,,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetOutlineTextMetricsW(HDC a0,
                                           UINT a1,
                                           LPOUTLINETEXTMETRICW a2)
{
    _PrintEnter("GetOutlineTextMetricsW(%lx,%lx,%lx)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetOutlineTextMetricsW(a0, a1, a2);
    } __finally {
        _PrintExit("GetOutlineTextMetricsW(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetOverlappedResult(HANDLE a0,
                                        LPOVERLAPPED a1,
                                        LPDWORD a2,
                                        BOOL a3)
{
    _PrintEnter("GetOverlappedResult(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetOverlappedResult(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetOverlappedResult(,,,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetPaletteEntries(HPALETTE a0,
                                      UINT a1,
                                      UINT a2,
                                      struct tagPALETTEENTRY* a3)
{
    _PrintEnter("GetPaletteEntries(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    UINT rv = 0;
    __try {
        rv = Real_GetPaletteEntries(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetPaletteEntries(,,,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetParent(HWND a0)
{
    _PrintEnter("GetParent(%lx)\n", a0);

    HWND rv = 0;
    __try {
        rv = Real_GetParent(a0);
    } __finally {
        _PrintExit("GetParent() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetPath(HDC a0,
                           struct tagPOINT* a1,
                           LPBYTE a2,
                           int a3)
{
    _PrintEnter("GetPath(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_GetPath(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetPath(,,,) -> %lx\n", rv);
    };
    return rv;
}

COLORREF __stdcall Mine_GetPixel(HDC a0,
                                 int a1,
                                 int a2)
{
    _PrintEnter("GetPixel(%lx,%lx,%lx)\n", a0, a1, a2);

    COLORREF rv = 0;
    __try {
        rv = Real_GetPixel(a0, a1, a2);
    } __finally {
        _PrintExit("GetPixel(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetPixelFormat(HDC a0)
{
    _PrintEnter("GetPixelFormat(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetPixelFormat(a0);
    } __finally {
        _PrintExit("GetPixelFormat() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetPolyFillMode(HDC a0)
{
    _PrintEnter("GetPolyFillMode(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetPolyFillMode(a0);
    } __finally {
        _PrintExit("GetPolyFillMode() -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetPriorityClass(HANDLE a0)
{
    _PrintEnter("GetPriorityClass(%lx)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetPriorityClass(a0);
    } __finally {
        _PrintExit("GetPriorityClass() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetPriorityClipboardFormat(UINT* a0,
                                              int a1)
{
    _PrintEnter("GetPriorityClipboardFormat(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_GetPriorityClipboardFormat(a0, a1);
    } __finally {
        _PrintExit("GetPriorityClipboardFormat(,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetPrivateProfileIntA(LPCSTR a0,
                                          LPCSTR a1,
                                          INT a2,
                                          LPCSTR a3)
{
    _PrintEnter("GetPrivateProfileIntA(%hs,%hs,%lx,%hs)\n", a0, a1, a2, a3);

    UINT rv = 0;
    __try {
        rv = Real_GetPrivateProfileIntA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetPrivateProfileIntA(,,,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetPrivateProfileIntW(LPCWSTR a0,
                                          LPCWSTR a1,
                                          INT a2,
                                          LPCWSTR a3)
{
    _PrintEnter("GetPrivateProfileIntW(%ls,%ls,%lx,%ls)\n", a0, a1, a2, a3);

    UINT rv = 0;
    __try {
        rv = Real_GetPrivateProfileIntW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetPrivateProfileIntW(,,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetPrivateProfileSectionA(LPCSTR a0,
                                               LPSTR a1,
                                               DWORD a2,
                                               LPCSTR a3)
{
    _PrintEnter("GetPrivateProfileSectionA(%hs,%lx,%lx,%hs)\n", a0, a1, a2, a3);

    DWORD rv = 0;
    __try {
        rv = Real_GetPrivateProfileSectionA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetPrivateProfileSectionA(,%hs,,) -> %lx\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetPrivateProfileSectionNamesA(LPSTR a0,
                                                    DWORD a1,
                                                    LPCSTR a2)
{
    _PrintEnter("GetPrivateProfileSectionNamesA(%lx,%lx,%hs)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetPrivateProfileSectionNamesA(a0, a1, a2);
    } __finally {
        _PrintExit("GetPrivateProfileSectionNamesA(%hs,,) -> %lx\n", a0, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetPrivateProfileSectionNamesW(LPWSTR a0,
                                                    DWORD a1,
                                                    LPCWSTR a2)
{
    _PrintEnter("GetPrivateProfileSectionNamesW(%lx,%lx,%ls)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetPrivateProfileSectionNamesW(a0, a1, a2);
    } __finally {
        _PrintExit("GetPrivateProfileSectionNamesW(%ls,,) -> %lx\n", a0, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetPrivateProfileSectionW(LPCWSTR a0,
                                               LPWSTR a1,
                                               DWORD a2,
                                               LPCWSTR a3)
{
    _PrintEnter("GetPrivateProfileSectionW(%ls,%lx,%lx,%ls)\n", a0, a1, a2, a3);

    DWORD rv = 0;
    __try {
        rv = Real_GetPrivateProfileSectionW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetPrivateProfileSectionW(,%ls,,) -> %lx\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetPrivateProfileStringA(LPCSTR a0,
                                              LPCSTR a1,
                                              LPCSTR a2,
                                              LPSTR a3,
                                              DWORD a4,
                                              LPCSTR a5)
{
    _PrintEnter("GetPrivateProfileStringA(%hs,%hs,%hs,%lx,%lx,%hs)\n", a0, a1, a2, a3, a4, a5);

    DWORD rv = 0;
    __try {
        rv = Real_GetPrivateProfileStringA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("GetPrivateProfileStringA(,,,%hs,,) -> %lx\n", a3, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetPrivateProfileStringW(LPCWSTR a0,
                                              LPCWSTR a1,
                                              LPCWSTR a2,
                                              LPWSTR a3,
                                              DWORD a4,
                                              LPCWSTR a5)
{
    _PrintEnter("GetPrivateProfileStringW(%ls,%ls,%ls,%lx,%lx,%ls)\n", a0, a1, a2, a3, a4, a5);

    DWORD rv = 0;
    __try {
        rv = Real_GetPrivateProfileStringW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("GetPrivateProfileStringW(,,,%ls,,) -> %lx\n", a3, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetPrivateProfileStructA(LPCSTR a0,
                                             LPCSTR a1,
                                             LPVOID a2,
                                             UINT a3,
                                             LPCSTR a4)
{
    _PrintEnter("GetPrivateProfileStructA(%hs,%hs,%lx,%lx,%hs)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_GetPrivateProfileStructA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetPrivateProfileStructA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetPrivateProfileStructW(LPCWSTR a0,
                                             LPCWSTR a1,
                                             LPVOID a2,
                                             UINT a3,
                                             LPCWSTR a4)
{
    _PrintEnter("GetPrivateProfileStructW(%ls,%ls,%lx,%lx,%ls)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_GetPrivateProfileStructW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetPrivateProfileStructW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

FARPROC __stdcall Mine_GetProcAddress(HMODULE a0,
                                      LPCSTR a1)
{
    _PrintEnter("GetProcAddress(%lx,%hs)\n", a0, a1);

    FARPROC rv = 0;
    __try {
        rv = Real_GetProcAddress(a0, a1);
    } __finally {
        _PrintExit("GetProcAddress(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetProcessAffinityMask(HANDLE a0,
                                           LPDWORD a1,
                                           LPDWORD a2)
{
    _PrintEnter("GetProcessAffinityMask(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetProcessAffinityMask(a0, a1, a2);
    } __finally {
        _PrintExit("GetProcessAffinityMask(,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetProcessHeaps(DWORD a0,
                                     PHANDLE a1)
{
    _PrintEnter("GetProcessHeaps(%lx,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetProcessHeaps(a0, a1);
    } __finally {
        _PrintExit("GetProcessHeaps(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetProcessPriorityBoost(HANDLE a0,
                                            PBOOL a1)
{
    _PrintEnter("GetProcessPriorityBoost(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetProcessPriorityBoost(a0, a1);
    } __finally {
        _PrintExit("GetProcessPriorityBoost(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetProcessShutdownParameters(LPDWORD a0,
                                                 LPDWORD a1)
{
    _PrintEnter("GetProcessShutdownParameters(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetProcessShutdownParameters(a0, a1);
    } __finally {
        _PrintExit("GetProcessShutdownParameters(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetProcessTimes(HANDLE a0,
                                    LPFILETIME a1,
                                    LPFILETIME a2,
                                    LPFILETIME a3,
                                    LPFILETIME a4)
{
    _PrintEnter("GetProcessTimes(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_GetProcessTimes(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetProcessTimes(,,,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetProcessVersion(DWORD a0)
{
    _PrintEnter("GetProcessVersion(%lx)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetProcessVersion(a0);
    } __finally {
        _PrintExit("GetProcessVersion() -> %lx\n", rv);
    };
    return rv;
}

HWINSTA __stdcall Mine_GetProcessWindowStation(void)
{
    _PrintEnter("GetProcessWindowStation()\n");

    HWINSTA rv = 0;
    __try {
        rv = Real_GetProcessWindowStation();
    } __finally {
        _PrintExit("GetProcessWindowStation() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetProcessWorkingSetSize(HANDLE a0,
                                             PSIZE_T a1,
                                             PSIZE_T a2)
{
    _PrintEnter("GetProcessWorkingSetSize(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetProcessWorkingSetSize(a0, a1, a2);
    } __finally {
        _PrintExit("GetProcessWorkingSetSize(,,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetProfileIntA(LPCSTR a0,
                                   LPCSTR a1,
                                   INT a2)
{
    _PrintEnter("GetProfileIntA(%hs,%hs,%lx)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetProfileIntA(a0, a1, a2);
    } __finally {
        _PrintExit("GetProfileIntA(,,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetProfileIntW(LPCWSTR a0,
                                   LPCWSTR a1,
                                   INT a2)
{
    _PrintEnter("GetProfileIntW(%ls,%ls,%lx)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GetProfileIntW(a0, a1, a2);
    } __finally {
        _PrintExit("GetProfileIntW(,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetProfileSectionA(LPCSTR a0,
                                        LPSTR a1,
                                        DWORD a2)
{
    _PrintEnter("GetProfileSectionA(%hs,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetProfileSectionA(a0, a1, a2);
    } __finally {
        _PrintExit("GetProfileSectionA(,%hs,) -> %lx\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetProfileSectionW(LPCWSTR a0,
                                        LPWSTR a1,
                                        DWORD a2)
{
    _PrintEnter("GetProfileSectionW(%ls,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetProfileSectionW(a0, a1, a2);
    } __finally {
        _PrintExit("GetProfileSectionW(,%ls,) -> %lx\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetProfileStringA(LPCSTR a0,
                                       LPCSTR a1,
                                       LPCSTR a2,
                                       LPSTR a3,
                                       DWORD a4)
{
    _PrintEnter("GetProfileStringA(%hs,%hs,%hs,%lx,%lx)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_GetProfileStringA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetProfileStringA(,,,%hs,) -> %lx\n", a3, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetProfileStringW(LPCWSTR a0,
                                       LPCWSTR a1,
                                       LPCWSTR a2,
                                       LPWSTR a3,
                                       DWORD a4)
{
    _PrintEnter("GetProfileStringW(%ls,%ls,%ls,%lx,%lx)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_GetProfileStringW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetProfileStringW(,,,%ls,) -> %lx\n", a3, rv);
    };
    return rv;
}

HANDLE __stdcall Mine_GetPropA(HWND a0,
                               LPCSTR a1)
{
    _PrintEnter("GetPropA(%lx,%hs)\n", a0, a1);

    HANDLE rv = 0;
    __try {
        rv = Real_GetPropA(a0, a1);
    } __finally {
        _PrintExit("GetPropA(,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_GetPropW(HWND a0,
                               LPCWSTR a1)
{
    _PrintEnter("GetPropW(%lx,%ls)\n", a0, a1);

    HANDLE rv = 0;
    __try {
        rv = Real_GetPropW(a0, a1);
    } __finally {
        _PrintExit("GetPropW(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetQueueStatus(UINT a0)
{
    _PrintEnter("GetQueueStatus(%lx)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetQueueStatus(a0);
    } __finally {
        _PrintExit("GetQueueStatus() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetQueuedCompletionStatus(HANDLE a0,
                                              LPDWORD a1,
                                              PULONG_PTR a2,
                                              LPOVERLAPPED* a3,
                                              DWORD a4)
{
    _PrintEnter("GetQueuedCompletionStatus(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_GetQueuedCompletionStatus(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetQueuedCompletionStatus(,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetROP2(HDC a0)
{
    _PrintEnter("GetROP2(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetROP2(a0);
    } __finally {
        _PrintExit("GetROP2() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetRasterizerCaps(LPRASTERIZER_STATUS a0,
                                      UINT a1)
{
    _PrintEnter("GetRasterizerCaps(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetRasterizerCaps(a0, a1);
    } __finally {
        _PrintExit("GetRasterizerCaps(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetRegionData(HRGN a0,
                                   DWORD a1,
                                   LPRGNDATA a2)
{
    _PrintEnter("GetRegionData(%lx,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetRegionData(a0, a1, a2);
    } __finally {
        _PrintExit("GetRegionData(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetRgnBox(HRGN a0,
                             LPRECT a1)
{
    _PrintEnter("GetRgnBox(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_GetRgnBox(a0, a1);
    } __finally {
        _PrintExit("GetRgnBox(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_GetRunningObjectTable(DWORD a0,
                                             LPRUNNINGOBJECTTABLE* a1)
{
    _PrintEnter("GetRunningObjectTable(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_GetRunningObjectTable(a0, a1);
    } __finally {
        _PrintExit("GetRunningObjectTable(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetScrollInfo(HWND a0,
                                  int a1,
                                  LPSCROLLINFO a2)
{
    _PrintEnter("GetScrollInfo(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetScrollInfo(a0, a1, a2);
    } __finally {
        _PrintExit("GetScrollInfo(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetScrollPos(HWND a0,
                                int a1)
{
    _PrintEnter("GetScrollPos(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_GetScrollPos(a0, a1);
    } __finally {
        _PrintExit("GetScrollPos(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetScrollRange(HWND a0,
                                   int a1,
                                   LPINT a2,
                                   LPINT a3)
{
    _PrintEnter("GetScrollRange(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetScrollRange(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetScrollRange(,,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetShortPathNameA(LPCSTR a0,
                                       LPSTR a1,
                                       DWORD a2)
{
    _PrintEnter("GetShortPathNameA(%hs,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetShortPathNameA(a0, a1, a2);
    } __finally {
        _PrintExit("GetShortPathNameA(,%hs,) -> %lx\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetShortPathNameW(LPCWSTR a0,
                                       LPWSTR a1,
                                       DWORD a2)
{
    _PrintEnter("GetShortPathNameW(%ls,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_GetShortPathNameW(a0, a1, a2);
    } __finally {
        _PrintExit("GetShortPathNameW(,%ls,) -> %lx\n", a1, rv);
    };
    return rv;
}

void __stdcall Mine_GetStartupInfoA(struct _STARTUPINFOA* a0)
{
    _PrintEnter("GetStartupInfoA(%lx)\n", a0);

    __try {
        Real_GetStartupInfoA(a0);
    } __finally {
        _PrintExit("GetStartupInfoA() ->\n");
    };
}

void __stdcall Mine_GetStartupInfoW(struct _STARTUPINFOW* a0)
{
    _PrintEnter("GetStartupInfoW(%lx)\n", a0);

    __try {
        Real_GetStartupInfoW(a0);
    } __finally {
        _PrintExit("GetStartupInfoW() ->\n");
    };
}

HANDLE __stdcall Mine_GetStdHandle(DWORD a0)
{
    _PrintEnter("GetStdHandle(%lx)\n", a0);

    HANDLE rv = 0;
    __try {
        rv = Real_GetStdHandle(a0);
    } __finally {
        _PrintExit("GetStdHandle() -> %lx\n", rv);
    };
    return rv;
}

HGDIOBJ __stdcall Mine_GetStockObject(int a0)
{
    _PrintEnter("GetStockObject(%lx)\n", a0);

    HGDIOBJ rv = 0;
    __try {
        rv = Real_GetStockObject(a0);
    } __finally {
        _PrintExit("GetStockObject() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetStretchBltMode(HDC a0)
{
    _PrintEnter("GetStretchBltMode(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetStretchBltMode(a0);
    } __finally {
        _PrintExit("GetStretchBltMode() -> %lx\n", rv);
    };
    return rv;
}

HMENU __stdcall Mine_GetSubMenu(HMENU a0,
                                int a1)
{
    _PrintEnter("GetSubMenu(%lx,%lx)\n", a0, a1);

    HMENU rv = 0;
    __try {
        rv = Real_GetSubMenu(a0, a1);
    } __finally {
        _PrintExit("GetSubMenu(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetSysColor(int a0)
{
    _PrintEnter("GetSysColor(%lx)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetSysColor(a0);
    } __finally {
        _PrintExit("GetSysColor() -> %lx\n", rv);
    };
    return rv;
}

HBRUSH __stdcall Mine_GetSysColorBrush(int a0)
{
    _PrintEnter("GetSysColorBrush(%lx)\n", a0);

    HBRUSH rv = 0;
    __try {
        rv = Real_GetSysColorBrush(a0);
    } __finally {
        _PrintExit("GetSysColorBrush() -> %lx\n", rv);
    };
    return rv;
}

LCID __stdcall Mine_GetSystemDefaultLCID(void)
{
    _PrintEnter("GetSystemDefaultLCID()\n");

    LCID rv = 0;
    __try {
        rv = Real_GetSystemDefaultLCID();
    } __finally {
        _PrintExit("GetSystemDefaultLCID() -> %lx\n", rv);
    };
    return rv;
}

LANGID __stdcall Mine_GetSystemDefaultLangID(void)
{
    _PrintEnter("GetSystemDefaultLangID()\n");

    LANGID rv = 0;
    __try {
        rv = Real_GetSystemDefaultLangID();
    } __finally {
        _PrintExit("GetSystemDefaultLangID() -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetSystemDirectoryA(LPSTR a0,
                                        UINT a1)
{
    _PrintEnter("GetSystemDirectoryA(%lx,%lx)\n", a0, a1);

    UINT rv = 0;
    __try {
        rv = Real_GetSystemDirectoryA(a0, a1);
    } __finally {
        _PrintExit("GetSystemDirectoryA(%hs,) -> %lx\n", a0, rv);
    };
    return rv;
}

UINT __stdcall Mine_GetSystemDirectoryW(LPWSTR a0,
                                        UINT a1)
{
    _PrintEnter("GetSystemDirectoryW(%lx,%lx)\n", a0, a1);

    UINT rv = 0;
    __try {
        rv = Real_GetSystemDirectoryW(a0, a1);
    } __finally {
        _PrintExit("GetSystemDirectoryW(%ls,) -> %lx\n", a0, rv);
    };
    return rv;
}

void __stdcall Mine_GetSystemInfo(struct _SYSTEM_INFO* a0)
{
    _PrintEnter("GetSystemInfo(%lx)\n", a0);

    __try {
        Real_GetSystemInfo(a0);
    } __finally {
        _PrintExit("GetSystemInfo() ->\n");
    };
}

HMENU __stdcall Mine_GetSystemMenu(HWND a0,
                                   BOOL a1)
{
    _PrintEnter("GetSystemMenu(%lx,%lx)\n", a0, a1);

    HMENU rv = 0;
    __try {
        rv = Real_GetSystemMenu(a0, a1);
    } __finally {
        _PrintExit("GetSystemMenu(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetSystemMetrics(int a0)
{
    _PrintEnter("GetSystemMetrics(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetSystemMetrics(a0);
    } __finally {
        _PrintExit("GetSystemMetrics() -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetSystemPaletteEntries(HDC a0,
                                            UINT a1,
                                            UINT a2,
                                            struct tagPALETTEENTRY* a3)
{
    _PrintEnter("GetSystemPaletteEntries(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    UINT rv = 0;
    __try {
        rv = Real_GetSystemPaletteEntries(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetSystemPaletteEntries(,,,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetSystemPaletteUse(HDC a0)
{
    _PrintEnter("GetSystemPaletteUse(%lx)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_GetSystemPaletteUse(a0);
    } __finally {
        _PrintExit("GetSystemPaletteUse() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetSystemPowerStatus(LPSYSTEM_POWER_STATUS a0)
{
    _PrintEnter("GetSystemPowerStatus(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_GetSystemPowerStatus(a0);
    } __finally {
        _PrintExit("GetSystemPowerStatus() -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_GetSystemTime(struct _SYSTEMTIME* a0)
{
    _PrintEnter("GetSystemTime(%lx)\n", a0);

    __try {
        Real_GetSystemTime(a0);
    } __finally {
        _PrintExit("GetSystemTime() ->\n");
    };
}

BOOL __stdcall Mine_GetSystemTimeAdjustment(PDWORD a0,
                                            PDWORD a1,
                                            PBOOL a2)
{
    _PrintEnter("GetSystemTimeAdjustment(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetSystemTimeAdjustment(a0, a1, a2);
    } __finally {
        _PrintExit("GetSystemTimeAdjustment(,,) -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_GetSystemTimeAsFileTime(LPFILETIME a0)
{
    _PrintEnter("GetSystemTimeAsFileTime(%lx)\n", a0);

    __try {
        Real_GetSystemTimeAsFileTime(a0);
    } __finally {
        _PrintExit("GetSystemTimeAsFileTime() ->\n");
    };
}

DWORD __stdcall Mine_GetTabbedTextExtentA(HDC a0,
                                          LPCSTR a1,
                                          int a2,
                                          int a3,
                                          INT* a4)
{
    _PrintEnter("GetTabbedTextExtentA(%lx,%hs,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_GetTabbedTextExtentA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetTabbedTextExtentA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetTabbedTextExtentW(HDC a0,
                                          LPCWSTR a1,
                                          int a2,
                                          int a3,
                                          INT* a4)
{
    _PrintEnter("GetTabbedTextExtentW(%lx,%ls,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_GetTabbedTextExtentW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetTabbedTextExtentW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetTapeParameters(HANDLE a0,
                                       DWORD a1,
                                       LPDWORD a2,
                                       LPVOID a3)
{
    _PrintEnter("GetTapeParameters(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    DWORD rv = 0;
    __try {
        rv = Real_GetTapeParameters(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetTapeParameters(,,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetTapePosition(HANDLE a0,
                                     DWORD a1,
                                     LPDWORD a2,
                                     LPDWORD a3,
                                     LPDWORD a4)
{
    _PrintEnter("GetTapePosition(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_GetTapePosition(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetTapePosition(,,,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetTapeStatus(HANDLE a0)
{
    _PrintEnter("GetTapeStatus(%lx)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetTapeStatus(a0);
    } __finally {
        _PrintExit("GetTapeStatus() -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetTempFileNameA(LPCSTR a0,
                                     LPCSTR a1,
                                     UINT a2,
                                     LPSTR a3)
{
    _PrintEnter("GetTempFileNameA(%hs,%hs,%lx,%lx)\n", a0, a1, a2, a3);

    UINT rv = 0;
    __try {
        rv = Real_GetTempFileNameA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetTempFileNameA(,,,%hs) -> %lx\n", a3, rv);
    };
    return rv;
}

UINT __stdcall Mine_GetTempFileNameW(LPCWSTR a0,
                                     LPCWSTR a1,
                                     UINT a2,
                                     LPWSTR a3)
{
    _PrintEnter("GetTempFileNameW(%ls,%ls,%lx,%lx)\n", a0, a1, a2, a3);

    UINT rv = 0;
    __try {
        rv = Real_GetTempFileNameW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetTempFileNameW(,,,%ls) -> %lx\n", a3, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetTempPathA(DWORD a0,
                                  LPSTR a1)
{
    _PrintEnter("GetTempPathA(%lx,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetTempPathA(a0, a1);
    } __finally {
        _PrintExit("GetTempPathA(,%hs) -> %lx\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetTempPathW(DWORD a0,
                                  LPWSTR a1)
{
    _PrintEnter("GetTempPathW(%lx,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetTempPathW(a0, a1);
    } __finally {
        _PrintExit("GetTempPathW(,%ls) -> %lx\n", a1, rv);
    };
    return rv;
}

UINT __stdcall Mine_GetTextAlign(HDC a0)
{
    _PrintEnter("GetTextAlign(%lx)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_GetTextAlign(a0);
    } __finally {
        _PrintExit("GetTextAlign() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetTextCharacterExtra(HDC a0)
{
    _PrintEnter("GetTextCharacterExtra(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetTextCharacterExtra(a0);
    } __finally {
        _PrintExit("GetTextCharacterExtra() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetTextCharset(HDC a0)
{
    _PrintEnter("GetTextCharset(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetTextCharset(a0);
    } __finally {
        _PrintExit("GetTextCharset() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetTextCharsetInfo(HDC a0,
                                      LPFONTSIGNATURE a1,
                                      DWORD a2)
{
    _PrintEnter("GetTextCharsetInfo(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetTextCharsetInfo(a0, a1, a2);
    } __finally {
        _PrintExit("GetTextCharsetInfo(,,) -> %lx\n", rv);
    };
    return rv;
}

COLORREF __stdcall Mine_GetTextColor(HDC a0)
{
    _PrintEnter("GetTextColor(%lx)\n", a0);

    COLORREF rv = 0;
    __try {
        rv = Real_GetTextColor(a0);
    } __finally {
        _PrintExit("GetTextColor() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetTextExtentExPointA(HDC a0,
                                          LPCSTR a1,
                                          int a2,
                                          int a3,
                                          LPINT a4,
                                          LPINT a5,
                                          struct tagSIZE* a6)
{
    _PrintEnter("GetTextExtentExPointA(%lx,%hs,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_GetTextExtentExPointA(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("GetTextExtentExPointA(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetTextExtentExPointW(HDC a0,
                                          LPCWSTR a1,
                                          int a2,
                                          int a3,
                                          LPINT a4,
                                          LPINT a5,
                                          struct tagSIZE* a6)
{
    _PrintEnter("GetTextExtentExPointW(%lx,%ls,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_GetTextExtentExPointW(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("GetTextExtentExPointW(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetTextExtentPoint32A(HDC a0,
                                          LPCSTR a1,
                                          int a2,
                                          struct tagSIZE* a3)
{
    _PrintEnter("GetTextExtentPoint32A(%lx,%hs,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetTextExtentPoint32A(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetTextExtentPoint32A(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetTextExtentPoint32W(HDC a0,
                                          LPCWSTR a1,
                                          int a2,
                                          struct tagSIZE* a3)
{
    _PrintEnter("GetTextExtentPoint32W(%lx,%ls,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetTextExtentPoint32W(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetTextExtentPoint32W(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetTextExtentPointA(HDC a0,
                                        LPCSTR a1,
                                        int a2,
                                        struct tagSIZE* a3)
{
    _PrintEnter("GetTextExtentPointA(%lx,%hs,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetTextExtentPointA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetTextExtentPointA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetTextExtentPointW(HDC a0,
                                        LPCWSTR a1,
                                        int a2,
                                        struct tagSIZE* a3)
{
    _PrintEnter("GetTextExtentPointW(%lx,%ls,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_GetTextExtentPointW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("GetTextExtentPointW(,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetTextFaceA(HDC a0,
                                int a1,
                                LPSTR a2)
{
    _PrintEnter("GetTextFaceA(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetTextFaceA(a0, a1, a2);
    } __finally {
        _PrintExit("GetTextFaceA(,,%hs) -> %lx\n", a2, rv);
    };
    return rv;
}

int __stdcall Mine_GetTextFaceW(HDC a0,
                                int a1,
                                LPWSTR a2)
{
    _PrintEnter("GetTextFaceW(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetTextFaceW(a0, a1, a2);
    } __finally {
        _PrintExit("GetTextFaceW(,,%ls) -> %lx\n", a2, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetTextMetricsA(HDC a0,
                                    LPTEXTMETRICA a1)
{
    _PrintEnter("GetTextMetricsA(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetTextMetricsA(a0, a1);
    } __finally {
        _PrintExit("GetTextMetricsA(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetTextMetricsW(HDC a0,
                                    LPTEXTMETRICW a1)
{
    _PrintEnter("GetTextMetricsW(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetTextMetricsW(a0, a1);
    } __finally {
        _PrintExit("GetTextMetricsW(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetThreadContext(HANDLE a0,
                                     LPCONTEXT a1)
{
    _PrintEnter("GetThreadContext(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetThreadContext(a0, a1);
    } __finally {
        _PrintExit("GetThreadContext(,) -> %lx\n", rv);
    };
    return rv;
}

HDESK __stdcall Mine_GetThreadDesktop(DWORD a0)
{
    _PrintEnter("GetThreadDesktop(%lx)\n", a0);

    HDESK rv = 0;
    __try {
        rv = Real_GetThreadDesktop(a0);
    } __finally {
        _PrintExit("GetThreadDesktop() -> %lx\n", rv);
    };
    return rv;
}

LCID __stdcall Mine_GetThreadLocale(void)
{
    _PrintEnter("GetThreadLocale()\n");

    LCID rv = 0;
    __try {
        rv = Real_GetThreadLocale();
    } __finally {
        _PrintExit("GetThreadLocale() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetThreadPriority(HANDLE a0)
{
    _PrintEnter("GetThreadPriority(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetThreadPriority(a0);
    } __finally {
        _PrintExit("GetThreadPriority() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetThreadPriorityBoost(HANDLE a0,
                                           PBOOL a1)
{
    _PrintEnter("GetThreadPriorityBoost(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetThreadPriorityBoost(a0, a1);
    } __finally {
        _PrintExit("GetThreadPriorityBoost(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetThreadSelectorEntry(HANDLE a0,
                                           DWORD a1,
                                           struct _LDT_ENTRY* a2)
{
    _PrintEnter("GetThreadSelectorEntry(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetThreadSelectorEntry(a0, a1, a2);
    } __finally {
        _PrintExit("GetThreadSelectorEntry(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetThreadTimes(HANDLE a0,
                                   LPFILETIME a1,
                                   LPFILETIME a2,
                                   LPFILETIME a3,
                                   LPFILETIME a4)
{
    _PrintEnter("GetThreadTimes(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_GetThreadTimes(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetThreadTimes(,,,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetTickCount(void)
{
    _PrintEnter("GetTickCount()\n");

    DWORD rv = 0;
    __try {
        rv = Real_GetTickCount();
    } __finally {
        _PrintExit("GetTickCount() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetTimeFormatA(LCID a0,
                                  DWORD a1,
                                  SYSTEMTIME* a2,
                                  LPCSTR a3,
                                  LPSTR a4,
                                  int a5)
{
    _PrintEnter("GetTimeFormatA(%lx,%lx,%lx,%hs,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_GetTimeFormatA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("GetTimeFormatA(,,,,%hs,) -> %lx\n", a4, rv);
    };
    return rv;
}

int __stdcall Mine_GetTimeFormatW(LCID a0,
                                  DWORD a1,
                                  SYSTEMTIME* a2,
                                  LPCWSTR a3,
                                  LPWSTR a4,
                                  int a5)
{
    _PrintEnter("GetTimeFormatW(%lx,%lx,%lx,%ls,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_GetTimeFormatW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("GetTimeFormatW(,,,,%ls,) -> %lx\n", a4, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetTimeZoneInformation(struct _TIME_ZONE_INFORMATION* a0)
{
    _PrintEnter("GetTimeZoneInformation(%lx)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetTimeZoneInformation(a0);
    } __finally {
        _PrintExit("GetTimeZoneInformation() -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetTopWindow(HWND a0)
{
    _PrintEnter("GetTopWindow(%lx)\n", a0);

    HWND rv = 0;
    __try {
        rv = Real_GetTopWindow(a0);
    } __finally {
        _PrintExit("GetTopWindow() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetUpdateRect(HWND a0,
                                  LPRECT a1,
                                  BOOL a2)
{
    _PrintEnter("GetUpdateRect(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_GetUpdateRect(a0, a1, a2);
    } __finally {
        _PrintExit("GetUpdateRect(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetUpdateRgn(HWND a0,
                                HRGN a1,
                                BOOL a2)
{
    _PrintEnter("GetUpdateRgn(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetUpdateRgn(a0, a1, a2);
    } __finally {
        _PrintExit("GetUpdateRgn(,,) -> %lx\n", rv);
    };
    return rv;
}

LCID __stdcall Mine_GetUserDefaultLCID(void)
{
    _PrintEnter("GetUserDefaultLCID()\n");

    LCID rv = 0;
    __try {
        rv = Real_GetUserDefaultLCID();
    } __finally {
        _PrintExit("GetUserDefaultLCID() -> %lx\n", rv);
    };
    return rv;
}

LANGID __stdcall Mine_GetUserDefaultLangID(void)
{
    _PrintEnter("GetUserDefaultLangID()\n");

    LANGID rv = 0;
    __try {
        rv = Real_GetUserDefaultLangID();
    } __finally {
        _PrintExit("GetUserDefaultLangID() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetUserObjectInformationA(HANDLE a0,
                                              int a1,
                                              PVOID a2,
                                              DWORD a3,
                                              LPDWORD a4)
{
    _PrintEnter("GetUserObjectInformationA(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_GetUserObjectInformationA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetUserObjectInformationA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetUserObjectInformationW(HANDLE a0,
                                              int a1,
                                              PVOID a2,
                                              DWORD a3,
                                              LPDWORD a4)
{
    _PrintEnter("GetUserObjectInformationW(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_GetUserObjectInformationW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetUserObjectInformationW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetUserObjectSecurity(HANDLE a0,
                                          PSECURITY_INFORMATION a1,
                                          PSECURITY_DESCRIPTOR a2,
                                          DWORD a3,
                                          LPDWORD a4)
{
    _PrintEnter("GetUserObjectSecurity(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_GetUserObjectSecurity(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetUserObjectSecurity(,,,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetVersion(void)
{
    _PrintEnter("GetVersion()\n");

    DWORD rv = 0;
    __try {
        rv = Real_GetVersion();
    } __finally {
        _PrintExit("GetVersion() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetVersionExA(LPOSVERSIONINFOA a0)
{
    _PrintEnter("GetVersionExA(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_GetVersionExA(a0);
    } __finally {
        _PrintExit("GetVersionExA() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetVersionExW(LPOSVERSIONINFOW a0)
{
    _PrintEnter("GetVersionExW(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_GetVersionExW(a0);
    } __finally {
        _PrintExit("GetVersionExW() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetViewportExtEx(HDC a0,
                                     struct tagSIZE* a1)
{
    _PrintEnter("GetViewportExtEx(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetViewportExtEx(a0, a1);
    } __finally {
        _PrintExit("GetViewportExtEx(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetViewportOrgEx(HDC a0,
                                     struct tagPOINT* a1)
{
    _PrintEnter("GetViewportOrgEx(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetViewportOrgEx(a0, a1);
    } __finally {
        _PrintExit("GetViewportOrgEx(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetVolumeInformationA(LPCSTR a0,
                                          LPSTR a1,
                                          DWORD a2,
                                          LPDWORD a3,
                                          LPDWORD a4,
                                          LPDWORD a5,
                                          LPSTR a6,
                                          DWORD a7)
{
    _PrintEnter("GetVolumeInformationA(%hs,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    BOOL rv = 0;
    __try {
        rv = Real_GetVolumeInformationA(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("GetVolumeInformationA(,%hs,,,,,%hs,) -> %lx\n", a1, a6, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetVolumeInformationW(LPCWSTR a0,
                                          LPWSTR a1,
                                          DWORD a2,
                                          LPDWORD a3,
                                          LPDWORD a4,
                                          LPDWORD a5,
                                          LPWSTR a6,
                                          DWORD a7)
{
    _PrintEnter("GetVolumeInformationW(%ls,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    BOOL rv = 0;
    __try {
        rv = Real_GetVolumeInformationW(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("GetVolumeInformationW(,%ls,,,,,%ls,) -> %lx\n", a1, a6, rv);
    };
    return rv;
}

UINT __stdcall Mine_GetWinMetaFileBits(HENHMETAFILE a0,
                                       UINT a1,
                                       LPBYTE a2,
                                       INT a3,
                                       HDC a4)
{
    _PrintEnter("GetWinMetaFileBits(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    UINT rv = 0;
    __try {
        rv = Real_GetWinMetaFileBits(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("GetWinMetaFileBits(,,,,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_GetWindow(HWND a0,
                              UINT a1)
{
    _PrintEnter("GetWindow(%lx,%lx)\n", a0, a1);

    HWND rv = 0;
    __try {
        rv = Real_GetWindow(a0, a1);
    } __finally {
        _PrintExit("GetWindow(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetWindowContextHelpId(HWND a0)
{
    _PrintEnter("GetWindowContextHelpId(%lx)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_GetWindowContextHelpId(a0);
    } __finally {
        _PrintExit("GetWindowContextHelpId() -> %lx\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_GetWindowDC(HWND a0)
{
    _PrintEnter("GetWindowDC(%lx)\n", a0);

    HDC rv = 0;
    __try {
        rv = Real_GetWindowDC(a0);
    } __finally {
        _PrintExit("GetWindowDC() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetWindowExtEx(HDC a0,
                                   struct tagSIZE* a1)
{
    _PrintEnter("GetWindowExtEx(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetWindowExtEx(a0, a1);
    } __finally {
        _PrintExit("GetWindowExtEx(,) -> %lx\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_GetWindowLongA(HWND a0,
                                   int a1)
{
    _PrintEnter("GetWindowLongA(%lx,%lx)\n", a0, a1);

    LONG rv = 0;
    __try {
        rv = Real_GetWindowLongA(a0, a1);
    } __finally {
        _PrintExit("GetWindowLongA(,) -> %lx\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_GetWindowLongW(HWND a0,
                                   int a1)
{
    _PrintEnter("GetWindowLongW(%lx,%lx)\n", a0, a1);

    LONG rv = 0;
    __try {
        rv = Real_GetWindowLongW(a0, a1);
    } __finally {
        _PrintExit("GetWindowLongW(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetWindowOrgEx(HDC a0,
                                   struct tagPOINT* a1)
{
    _PrintEnter("GetWindowOrgEx(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetWindowOrgEx(a0, a1);
    } __finally {
        _PrintExit("GetWindowOrgEx(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetWindowPlacement(HWND a0,
                                       struct tagWINDOWPLACEMENT* a1)
{
    _PrintEnter("GetWindowPlacement(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetWindowPlacement(a0, a1);
    } __finally {
        _PrintExit("GetWindowPlacement(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetWindowRect(HWND a0,
                                  LPRECT a1)
{
    _PrintEnter("GetWindowRect(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetWindowRect(a0, a1);
    } __finally {
        _PrintExit("GetWindowRect(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetWindowRgn(HWND a0,
                                HRGN a1)
{
    _PrintEnter("GetWindowRgn(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_GetWindowRgn(a0, a1);
    } __finally {
        _PrintExit("GetWindowRgn(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetWindowTextA(HWND a0,
                                  LPSTR a1,
                                  int a2)
{
    _PrintEnter("GetWindowTextA(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetWindowTextA(a0, a1, a2);
    } __finally {
        _PrintExit("GetWindowTextA(,%hs,) -> %lx\n", a1, rv);
    };
    return rv;
}

int __stdcall Mine_GetWindowTextLengthA(HWND a0)
{
    _PrintEnter("GetWindowTextLengthA(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetWindowTextLengthA(a0);
    } __finally {
        _PrintExit("GetWindowTextLengthA() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetWindowTextLengthW(HWND a0)
{
    _PrintEnter("GetWindowTextLengthW(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_GetWindowTextLengthW(a0);
    } __finally {
        _PrintExit("GetWindowTextLengthW() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_GetWindowTextW(HWND a0,
                                  LPWSTR a1,
                                  int a2)
{
    _PrintEnter("GetWindowTextW(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_GetWindowTextW(a0, a1, a2);
    } __finally {
        _PrintExit("GetWindowTextW(,%ls,) -> %lx\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_GetWindowThreadProcessId(HWND a0,
                                              LPDWORD a1)
{
    _PrintEnter("GetWindowThreadProcessId(%lx,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_GetWindowThreadProcessId(a0, a1);
    } __finally {
        _PrintExit("GetWindowThreadProcessId(,) -> %lx\n", rv);
    };
    return rv;
}

WORD __stdcall Mine_GetWindowWord(HWND a0,
                                  int a1)
{
    _PrintEnter("GetWindowWord(%lx,%lx)\n", a0, a1);

    WORD rv = 0;
    __try {
        rv = Real_GetWindowWord(a0, a1);
    } __finally {
        _PrintExit("GetWindowWord(,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GetWindowsDirectoryA(LPSTR a0,
                                         UINT a1)
{
    _PrintEnter("GetWindowsDirectoryA(%lx,%lx)\n", a0, a1);

    UINT rv = 0;
    __try {
        rv = Real_GetWindowsDirectoryA(a0, a1);
    } __finally {
        _PrintExit("GetWindowsDirectoryA(%hs,) -> %lx\n", a0, rv);
    };
    return rv;
}

UINT __stdcall Mine_GetWindowsDirectoryW(LPWSTR a0,
                                         UINT a1)
{
    _PrintEnter("GetWindowsDirectoryW(%lx,%lx)\n", a0, a1);

    UINT rv = 0;
    __try {
        rv = Real_GetWindowsDirectoryW(a0, a1);
    } __finally {
        _PrintExit("GetWindowsDirectoryW(%ls,) -> %lx\n", a0, rv);
    };
    return rv;
}

BOOL __stdcall Mine_GetWorldTransform(HDC a0,
                                      struct tagXFORM* a1)
{
    _PrintEnter("GetWorldTransform(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_GetWorldTransform(a0, a1);
    } __finally {
        _PrintExit("GetWorldTransform(,) -> %lx\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_GlobalAddAtomA(LPCSTR a0)
{
    _PrintEnter("GlobalAddAtomA(%hs)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_GlobalAddAtomA(a0);
    } __finally {
        _PrintExit("GlobalAddAtomA() -> %lx\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_GlobalAddAtomW(LPCWSTR a0)
{
    _PrintEnter("GlobalAddAtomW(%ls)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_GlobalAddAtomW(a0);
    } __finally {
        _PrintExit("GlobalAddAtomW() -> %lx\n", rv);
    };
    return rv;
}

HGLOBAL __stdcall Mine_GlobalAlloc(UINT a0,
                                   SIZE_T a1)
{
    _PrintEnter("GlobalAlloc(%lx,%lx)\n", a0, a1);

    HGLOBAL rv = 0;
    __try {
        rv = Real_GlobalAlloc(a0, a1);
    } __finally {
        _PrintExit("GlobalAlloc(,) -> %lx\n", rv);
    };
    return rv;
}

SIZE_T __stdcall Mine_GlobalCompact(DWORD a0)
{
    _PrintEnter("GlobalCompact(%lx)\n", a0);

    SIZE_T rv = 0;
    __try {
        rv = Real_GlobalCompact(a0);
    } __finally {
        _PrintExit("GlobalCompact() -> %lx\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_GlobalDeleteAtom(ATOM a0)
{
    _PrintEnter("GlobalDeleteAtom(%lx)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_GlobalDeleteAtom(a0);
    } __finally {
        _PrintExit("GlobalDeleteAtom() -> %lx\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_GlobalFindAtomA(LPCSTR a0)
{
    _PrintEnter("GlobalFindAtomA(%hs)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_GlobalFindAtomA(a0);
    } __finally {
        _PrintExit("GlobalFindAtomA() -> %lx\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_GlobalFindAtomW(LPCWSTR a0)
{
    _PrintEnter("GlobalFindAtomW(%ls)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_GlobalFindAtomW(a0);
    } __finally {
        _PrintExit("GlobalFindAtomW() -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_GlobalFix(HGLOBAL a0)
{
    _PrintEnter("GlobalFix(%lx)\n", a0);

    __try {
        Real_GlobalFix(a0);
    } __finally {
        _PrintExit("GlobalFix() ->\n");
    };
}

UINT __stdcall Mine_GlobalFlags(HGLOBAL a0)
{
    _PrintEnter("GlobalFlags(%lx)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_GlobalFlags(a0);
    } __finally {
        _PrintExit("GlobalFlags() -> %lx\n", rv);
    };
    return rv;
}

HGLOBAL __stdcall Mine_GlobalFree(HGLOBAL a0)
{
    _PrintEnter("GlobalFree(%lx)\n", a0);

    HGLOBAL rv = 0;
    __try {
        rv = Real_GlobalFree(a0);
    } __finally {
        _PrintExit("GlobalFree() -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_GlobalGetAtomNameA(ATOM a0,
                                       LPSTR a1,
                                       int a2)
{
    _PrintEnter("GlobalGetAtomNameA(%lx,%lx,%lx)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GlobalGetAtomNameA(a0, a1, a2);
    } __finally {
        _PrintExit("GlobalGetAtomNameA(,%hs,) -> %lx\n", a1, rv);
    };
    return rv;
}

UINT __stdcall Mine_GlobalGetAtomNameW(ATOM a0,
                                       LPWSTR a1,
                                       int a2)
{
    _PrintEnter("GlobalGetAtomNameW(%lx,%lx,%lx)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_GlobalGetAtomNameW(a0, a1, a2);
    } __finally {
        _PrintExit("GlobalGetAtomNameW(,%ls,) -> %lx\n", a1, rv);
    };
    return rv;
}

HGLOBAL __stdcall Mine_GlobalHandle(LPCVOID a0)
{
    _PrintEnter("GlobalHandle(%lx)\n", a0);

    HGLOBAL rv = 0;
    __try {
        rv = Real_GlobalHandle(a0);
    } __finally {
        _PrintExit("GlobalHandle() -> %lx\n", rv);
    };
    return rv;
}

LPVOID __stdcall Mine_GlobalLock(HGLOBAL a0)
{
    _PrintEnter("GlobalLock(%lx)\n", a0);

    LPVOID rv = 0;
    __try {
        rv = Real_GlobalLock(a0);
    } __finally {
        _PrintExit("GlobalLock() -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_GlobalMemoryStatus(LPMEMORYSTATUS a0)
{
    _PrintEnter("GlobalMemoryStatus(%lx)\n", a0);

    __try {
        Real_GlobalMemoryStatus(a0);
    } __finally {
        _PrintExit("GlobalMemoryStatus() ->\n");
    };
}

HGLOBAL __stdcall Mine_GlobalReAlloc(HGLOBAL a0,
                                     SIZE_T a1,
                                     UINT a2)
{
    _PrintEnter("GlobalReAlloc(%lx,%lx,%lx)\n", a0, a1, a2);

    HGLOBAL rv = 0;
    __try {
        rv = Real_GlobalReAlloc(a0, a1, a2);
    } __finally {
        _PrintExit("GlobalReAlloc(,,) -> %lx\n", rv);
    };
    return rv;
}

SIZE_T __stdcall Mine_GlobalSize(HGLOBAL a0)
{
    _PrintEnter("GlobalSize(%lx)\n", a0);

    SIZE_T rv = 0;
    __try {
        rv = Real_GlobalSize(a0);
    } __finally {
        _PrintExit("GlobalSize() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GlobalUnWire(HGLOBAL a0)
{
    _PrintEnter("GlobalUnWire(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_GlobalUnWire(a0);
    } __finally {
        _PrintExit("GlobalUnWire() -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_GlobalUnfix(HGLOBAL a0)
{
    _PrintEnter("GlobalUnfix(%lx)\n", a0);

    __try {
        Real_GlobalUnfix(a0);
    } __finally {
        _PrintExit("GlobalUnfix() ->\n");
    };
}

BOOL __stdcall Mine_GlobalUnlock(HGLOBAL a0)
{
    _PrintEnter("GlobalUnlock(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_GlobalUnlock(a0);
    } __finally {
        _PrintExit("GlobalUnlock() -> %lx\n", rv);
    };
    return rv;
}

LPVOID __stdcall Mine_GlobalWire(HGLOBAL a0)
{
    _PrintEnter("GlobalWire(%lx)\n", a0);

    LPVOID rv = 0;
    __try {
        rv = Real_GlobalWire(a0);
    } __finally {
        _PrintExit("GlobalWire() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GrayStringA(HDC a0,
                                HBRUSH a1,
                                GRAYSTRINGPROC a2,
                                LPARAM a3,
                                int a4,
                                int a5,
                                int a6,
                                int a7,
                                int a8)
{
    _PrintEnter("GrayStringA(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8);

    BOOL rv = 0;
    __try {
        rv = Real_GrayStringA(a0, a1, a2, a3, a4, a5, a6, a7, a8);
    } __finally {
        _PrintExit("GrayStringA(,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_GrayStringW(HDC a0,
                                HBRUSH a1,
                                GRAYSTRINGPROC a2,
                                LPARAM a3,
                                int a4,
                                int a5,
                                int a6,
                                int a7,
                                int a8)
{
    _PrintEnter("GrayStringW(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8);

    BOOL rv = 0;
    __try {
        rv = Real_GrayStringW(a0, a1, a2, a3, a4, a5, a6, a7, a8);
    } __finally {
        _PrintExit("GrayStringW(,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_HeapLock(HANDLE a0)
{
    _PrintEnter("HeapLock(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_HeapLock(a0);
    } __finally {
        _PrintExit("HeapLock() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_HeapUnlock(HANDLE a0)
{
    _PrintEnter("HeapUnlock(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_HeapUnlock(a0);
    } __finally {
        _PrintExit("HeapUnlock() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_HideCaret(HWND a0)
{
    _PrintEnter("HideCaret(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_HideCaret(a0);
    } __finally {
        _PrintExit("HideCaret() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_HiliteMenuItem(HWND a0,
                                   HMENU a1,
                                   UINT a2,
                                   UINT a3)
{
    _PrintEnter("HiliteMenuItem(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_HiliteMenuItem(a0, a1, a2, a3);
    } __finally {
        _PrintExit("HiliteMenuItem(,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_IIDFromString(LPOLESTR a0,
                                     struct _GUID* a1)
{
    _PrintEnter("IIDFromString(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_IIDFromString(a0, a1);
    } __finally {
        _PrintExit("IIDFromString(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ImpersonateDdeClientWindow(HWND a0,
                                               HWND a1)
{
    _PrintEnter("ImpersonateDdeClientWindow(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_ImpersonateDdeClientWindow(a0, a1);
    } __finally {
        _PrintExit("ImpersonateDdeClientWindow(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_InSendMessage(void)
{
    _PrintEnter("InSendMessage()\n");

    BOOL rv = 0;
    __try {
        rv = Real_InSendMessage();
    } __finally {
        _PrintExit("InSendMessage() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_InflateRect(LPRECT a0,
                                int a1,
                                int a2)
{
    _PrintEnter("InflateRect(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_InflateRect(a0, a1, a2);
    } __finally {
        _PrintExit("InflateRect(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_InitAtomTable(DWORD a0)
{
    _PrintEnter("InitAtomTable(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_InitAtomTable(a0);
    } __finally {
        _PrintExit("InitAtomTable() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_InsertMenuA(HMENU a0,
                                UINT a1,
                                UINT a2,
                                UINT_PTR a3,
                                LPCSTR a4)
{
    _PrintEnter("InsertMenuA(%lx,%lx,%lx,%lx,%hs)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_InsertMenuA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("InsertMenuA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_InsertMenuItemA(HMENU a0,
                                    UINT a1,
                                    BOOL a2,
                                    struct tagMENUITEMINFOA* a3)
{
    _PrintEnter("InsertMenuItemA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_InsertMenuItemA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("InsertMenuItemA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_InsertMenuItemW(HMENU a0,
                                    UINT a1,
                                    BOOL a2,
                                    struct tagMENUITEMINFOW* a3)
{
    _PrintEnter("InsertMenuItemW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_InsertMenuItemW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("InsertMenuItemW(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_InsertMenuW(HMENU a0,
                                UINT a1,
                                UINT a2,
                                UINT_PTR a3,
                                LPCWSTR a4)
{
    _PrintEnter("InsertMenuW(%lx,%lx,%lx,%lx,%ls)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_InsertMenuW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("InsertMenuW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_IntersectClipRect(HDC a0,
                                     int a1,
                                     int a2,
                                     int a3,
                                     int a4)
{
    _PrintEnter("IntersectClipRect(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_IntersectClipRect(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("IntersectClipRect(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IntersectRect(LPRECT a0,
                                  RECT* a1,
                                  RECT* a2)
{
    _PrintEnter("IntersectRect(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_IntersectRect(a0, a1, a2);
    } __finally {
        _PrintExit("IntersectRect(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_InvalidateRect(HWND a0,
                                   RECT* a1,
                                   BOOL a2)
{
    _PrintEnter("InvalidateRect(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_InvalidateRect(a0, a1, a2);
    } __finally {
        _PrintExit("InvalidateRect(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_InvalidateRgn(HWND a0,
                                  HRGN a1,
                                  BOOL a2)
{
    _PrintEnter("InvalidateRgn(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_InvalidateRgn(a0, a1, a2);
    } __finally {
        _PrintExit("InvalidateRgn(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_InvertRect(HDC a0,
                               RECT* a1)
{
    _PrintEnter("InvertRect(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_InvertRect(a0, a1);
    } __finally {
        _PrintExit("InvertRect(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_InvertRgn(HDC a0,
                              HRGN a1)
{
    _PrintEnter("InvertRgn(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_InvertRgn(a0, a1);
    } __finally {
        _PrintExit("InvertRgn(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsAccelerator(HACCEL a0,
                                  int a1,
                                  LPMSG a2,
                                  WORD* a3)
{
    _PrintEnter("IsAccelerator(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_IsAccelerator(a0, a1, a2, a3);
    } __finally {
        _PrintExit("IsAccelerator(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsBadCodePtr(FARPROC a0)
{
    _PrintEnter("IsBadCodePtr(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsBadCodePtr(a0);
    } __finally {
        _PrintExit("IsBadCodePtr() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsBadHugeReadPtr(void* a0,
                                     UINT_PTR a1)
{
    _PrintEnter("IsBadHugeReadPtr(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_IsBadHugeReadPtr(a0, a1);
    } __finally {
        _PrintExit("IsBadHugeReadPtr(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsBadHugeWritePtr(LPVOID a0,
                                      UINT_PTR a1)
{
    _PrintEnter("IsBadHugeWritePtr(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_IsBadHugeWritePtr(a0, a1);
    } __finally {
        _PrintExit("IsBadHugeWritePtr(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsBadReadPtr(void* a0,
                                 UINT_PTR a1)
{
    _PrintEnter("IsBadReadPtr(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_IsBadReadPtr(a0, a1);
    } __finally {
        _PrintExit("IsBadReadPtr(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsBadStringPtrA(LPCSTR a0,
                                    UINT_PTR a1)
{
    _PrintEnter("IsBadStringPtrA(%hs,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_IsBadStringPtrA(a0, a1);
    } __finally {
        _PrintExit("IsBadStringPtrA(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsBadStringPtrW(LPCWSTR a0,
                                    UINT_PTR a1)
{
    _PrintEnter("IsBadStringPtrW(%ls,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_IsBadStringPtrW(a0, a1);
    } __finally {
        _PrintExit("IsBadStringPtrW(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsBadWritePtr(LPVOID a0,
                                  UINT_PTR a1)
{
    _PrintEnter("IsBadWritePtr(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_IsBadWritePtr(a0, a1);
    } __finally {
        _PrintExit("IsBadWritePtr(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsCharAlphaA(CHAR a0)
{
    _PrintEnter("IsCharAlphaA(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsCharAlphaA(a0);
    } __finally {
        _PrintExit("IsCharAlphaA() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsCharAlphaNumericA(CHAR a0)
{
    _PrintEnter("IsCharAlphaNumericA(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsCharAlphaNumericA(a0);
    } __finally {
        _PrintExit("IsCharAlphaNumericA() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsCharAlphaNumericW(WCHAR a0)
{
    _PrintEnter("IsCharAlphaNumericW(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsCharAlphaNumericW(a0);
    } __finally {
        _PrintExit("IsCharAlphaNumericW() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsCharAlphaW(WCHAR a0)
{
    _PrintEnter("IsCharAlphaW(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsCharAlphaW(a0);
    } __finally {
        _PrintExit("IsCharAlphaW() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsCharLowerA(CHAR a0)
{
    _PrintEnter("IsCharLowerA(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsCharLowerA(a0);
    } __finally {
        _PrintExit("IsCharLowerA() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsCharLowerW(WCHAR a0)
{
    _PrintEnter("IsCharLowerW(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsCharLowerW(a0);
    } __finally {
        _PrintExit("IsCharLowerW() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsCharUpperA(CHAR a0)
{
    _PrintEnter("IsCharUpperA(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsCharUpperA(a0);
    } __finally {
        _PrintExit("IsCharUpperA() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsCharUpperW(WCHAR a0)
{
    _PrintEnter("IsCharUpperW(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsCharUpperW(a0);
    } __finally {
        _PrintExit("IsCharUpperW() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsChild(HWND a0,
                            HWND a1)
{
    _PrintEnter("IsChild(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_IsChild(a0, a1);
    } __finally {
        _PrintExit("IsChild(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsClipboardFormatAvailable(UINT a0)
{
    _PrintEnter("IsClipboardFormatAvailable(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsClipboardFormatAvailable(a0);
    } __finally {
        _PrintExit("IsClipboardFormatAvailable() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsDBCSLeadByte(BYTE a0)
{
    _PrintEnter("IsDBCSLeadByte(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsDBCSLeadByte(a0);
    } __finally {
        _PrintExit("IsDBCSLeadByte() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsDBCSLeadByteEx(UINT a0,
                                     BYTE a1)
{
    _PrintEnter("IsDBCSLeadByteEx(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_IsDBCSLeadByteEx(a0, a1);
    } __finally {
        _PrintExit("IsDBCSLeadByteEx(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsDebuggerPresent(void)
{
    _PrintEnter("IsDebuggerPresent()\n");

    BOOL rv = 0;
    __try {
        rv = Real_IsDebuggerPresent();
    } __finally {
        _PrintExit("IsDebuggerPresent() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsDialogMessageA(HWND a0,
                                     LPMSG a1)
{
    _PrintEnter("IsDialogMessageA(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_IsDialogMessageA(a0, a1);
    } __finally {
        _PrintExit("IsDialogMessageA(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsDialogMessageW(HWND a0,
                                     LPMSG a1)
{
    _PrintEnter("IsDialogMessageW(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_IsDialogMessageW(a0, a1);
    } __finally {
        _PrintExit("IsDialogMessageW(,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_IsDlgButtonChecked(HWND a0,
                                       int a1)
{
    _PrintEnter("IsDlgButtonChecked(%lx,%lx)\n", a0, a1);

    UINT rv = 0;
    __try {
        rv = Real_IsDlgButtonChecked(a0, a1);
    } __finally {
        _PrintExit("IsDlgButtonChecked(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsIconic(HWND a0)
{
    _PrintEnter("IsIconic(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsIconic(a0);
    } __finally {
        _PrintExit("IsIconic() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsMenu(HMENU a0)
{
    _PrintEnter("IsMenu(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsMenu(a0);
    } __finally {
        _PrintExit("IsMenu() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsProcessorFeaturePresent(DWORD a0)
{
    _PrintEnter("IsProcessorFeaturePresent(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsProcessorFeaturePresent(a0);
    } __finally {
        _PrintExit("IsProcessorFeaturePresent() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsRectEmpty(RECT* a0)
{
    _PrintEnter("IsRectEmpty(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsRectEmpty(a0);
    } __finally {
        _PrintExit("IsRectEmpty() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsValidCodePage(UINT a0)
{
    _PrintEnter("IsValidCodePage(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsValidCodePage(a0);
    } __finally {
        _PrintExit("IsValidCodePage() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsValidLocale(LCID a0,
                                  DWORD a1)
{
    _PrintEnter("IsValidLocale(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_IsValidLocale(a0, a1);
    } __finally {
        _PrintExit("IsValidLocale(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsWindow(HWND a0)
{
    _PrintEnter("IsWindow(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsWindow(a0);
    } __finally {
        _PrintExit("IsWindow() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsWindowEnabled(HWND a0)
{
    _PrintEnter("IsWindowEnabled(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsWindowEnabled(a0);
    } __finally {
        _PrintExit("IsWindowEnabled() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsWindowUnicode(HWND a0)
{
    _PrintEnter("IsWindowUnicode(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsWindowUnicode(a0);
    } __finally {
        _PrintExit("IsWindowUnicode() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsWindowVisible(HWND a0)
{
    _PrintEnter("IsWindowVisible(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsWindowVisible(a0);
    } __finally {
        _PrintExit("IsWindowVisible() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_IsZoomed(HWND a0)
{
    _PrintEnter("IsZoomed(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_IsZoomed(a0);
    } __finally {
        _PrintExit("IsZoomed() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_KillTimer(HWND a0,
                              UINT_PTR a1)
{
    _PrintEnter("KillTimer(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_KillTimer(a0, a1);
    } __finally {
        _PrintExit("KillTimer(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_LPtoDP(HDC a0,
                           struct tagPOINT* a1,
                           int a2)
{
    _PrintEnter("LPtoDP(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_LPtoDP(a0, a1, a2);
    } __finally {
        _PrintExit("LPtoDP(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_LineDDA(int a0,
                            int a1,
                            int a2,
                            int a3,
                            LINEDDAPROC a4,
                            LPARAM a5)
{
    _PrintEnter("LineDDA(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_LineDDA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("LineDDA(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_LineTo(HDC a0,
                           int a1,
                           int a2)
{
    _PrintEnter("LineTo(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_LineTo(a0, a1, a2);
    } __finally {
        _PrintExit("LineTo(,,) -> %lx\n", rv);
    };
    return rv;
}

HACCEL __stdcall Mine_LoadAcceleratorsA(HINSTANCE a0,
                                        LPCSTR a1)
{
    _PrintEnter("LoadAcceleratorsA(%lx,%hs)\n", a0, a1);

    HACCEL rv = 0;
    __try {
        rv = Real_LoadAcceleratorsA(a0, a1);
    } __finally {
        _PrintExit("LoadAcceleratorsA(,) -> %lx\n", rv);
    };
    return rv;
}

HACCEL __stdcall Mine_LoadAcceleratorsW(HINSTANCE a0,
                                        LPCWSTR a1)
{
    _PrintEnter("LoadAcceleratorsW(%lx,%ls)\n", a0, a1);

    HACCEL rv = 0;
    __try {
        rv = Real_LoadAcceleratorsW(a0, a1);
    } __finally {
        _PrintExit("LoadAcceleratorsW(,) -> %lx\n", rv);
    };
    return rv;
}

HBITMAP __stdcall Mine_LoadBitmapA(HINSTANCE a0,
                                   LPCSTR a1)
{
    _PrintEnter("LoadBitmapA(%lx,%hs)\n", a0, a1);

    HBITMAP rv = 0;
    __try {
        rv = Real_LoadBitmapA(a0, a1);
    } __finally {
        _PrintExit("LoadBitmapA(,) -> %lx\n", rv);
    };
    return rv;
}

HBITMAP __stdcall Mine_LoadBitmapW(HINSTANCE a0,
                                   LPCWSTR a1)
{
    _PrintEnter("LoadBitmapW(%lx,%ls)\n", a0, a1);

    HBITMAP rv = 0;
    __try {
        rv = Real_LoadBitmapW(a0, a1);
    } __finally {
        _PrintExit("LoadBitmapW(,) -> %lx\n", rv);
    };
    return rv;
}

HCURSOR __stdcall Mine_LoadCursorA(HINSTANCE a0,
                                   LPCSTR a1)
{
    _PrintEnter("LoadCursorA(%lx,%hs)\n", a0, a1);

    HCURSOR rv = 0;
    __try {
        rv = Real_LoadCursorA(a0, a1);
    } __finally {
        _PrintExit("LoadCursorA(,) -> %lx\n", rv);
    };
    return rv;
}

HCURSOR __stdcall Mine_LoadCursorFromFileA(LPCSTR a0)
{
    _PrintEnter("LoadCursorFromFileA(%hs)\n", a0);

    HCURSOR rv = 0;
    __try {
        rv = Real_LoadCursorFromFileA(a0);
    } __finally {
        _PrintExit("LoadCursorFromFileA() -> %lx\n", rv);
    };
    return rv;
}

HCURSOR __stdcall Mine_LoadCursorFromFileW(LPCWSTR a0)
{
    _PrintEnter("LoadCursorFromFileW(%ls)\n", a0);

    HCURSOR rv = 0;
    __try {
        rv = Real_LoadCursorFromFileW(a0);
    } __finally {
        _PrintExit("LoadCursorFromFileW() -> %lx\n", rv);
    };
    return rv;
}

HCURSOR __stdcall Mine_LoadCursorW(HINSTANCE a0,
                                   LPCWSTR a1)
{
    _PrintEnter("LoadCursorW(%lx,%ls)\n", a0, a1);

    HCURSOR rv = 0;
    __try {
        rv = Real_LoadCursorW(a0, a1);
    } __finally {
        _PrintExit("LoadCursorW(,) -> %lx\n", rv);
    };
    return rv;
}

HICON __stdcall Mine_LoadIconA(HINSTANCE a0,
                               LPCSTR a1)
{
    _PrintEnter("LoadIconA(%lx,%hs)\n", a0, a1);

    HICON rv = 0;
    __try {
        rv = Real_LoadIconA(a0, a1);
    } __finally {
        _PrintExit("LoadIconA(,) -> %lx\n", rv);
    };
    return rv;
}

HICON __stdcall Mine_LoadIconW(HINSTANCE a0,
                               LPCWSTR a1)
{
    _PrintEnter("LoadIconW(%lx,%ls)\n", a0, a1);

    HICON rv = 0;
    __try {
        rv = Real_LoadIconW(a0, a1);
    } __finally {
        _PrintExit("LoadIconW(,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_LoadImageA(HINSTANCE a0,
                                 LPCSTR a1,
                                 UINT a2,
                                 int a3,
                                 int a4,
                                 UINT a5)
{
    _PrintEnter("LoadImageA(%lx,%hs,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    HANDLE rv = 0;
    __try {
        rv = Real_LoadImageA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("LoadImageA(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_LoadImageW(HINSTANCE a0,
                                 LPCWSTR a1,
                                 UINT a2,
                                 int a3,
                                 int a4,
                                 UINT a5)
{
    _PrintEnter("LoadImageW(%lx,%ls,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    HANDLE rv = 0;
    __try {
        rv = Real_LoadImageW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("LoadImageW(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HKL __stdcall Mine_LoadKeyboardLayoutA(LPCSTR a0,
                                       UINT a1)
{
    _PrintEnter("LoadKeyboardLayoutA(%hs,%lx)\n", a0, a1);

    HKL rv = 0;
    __try {
        rv = Real_LoadKeyboardLayoutA(a0, a1);
    } __finally {
        _PrintExit("LoadKeyboardLayoutA(,) -> %lx\n", rv);
    };
    return rv;
}

HKL __stdcall Mine_LoadKeyboardLayoutW(LPCWSTR a0,
                                       UINT a1)
{
    _PrintEnter("LoadKeyboardLayoutW(%ls,%lx)\n", a0, a1);

    HKL rv = 0;
    __try {
        rv = Real_LoadKeyboardLayoutW(a0, a1);
    } __finally {
        _PrintExit("LoadKeyboardLayoutW(,) -> %lx\n", rv);
    };
    return rv;
}

HMODULE __stdcall Mine_LoadLibraryA(LPCSTR a0)
{
    _PrintEnter("LoadLibraryA(%hs)\n", a0);

    HMODULE rv = 0;
    __try {
        rv = Real_LoadLibraryA(a0);
    } __finally {
        _PrintExit("LoadLibraryA() -> %lx\n", rv);
    };
    return rv;
}

HMODULE __stdcall Mine_LoadLibraryExA(LPCSTR a0,
                                      HANDLE a1,
                                      DWORD a2)
{
    _PrintEnter("LoadLibraryExA(%hs,%lx,%lx)\n", a0, a1, a2);

    HMODULE rv = 0;
    __try {
        rv = Real_LoadLibraryExA(a0, a1, a2);
    } __finally {
        _PrintExit("LoadLibraryExA(,,) -> %lx\n", rv);
    };
    return rv;
}

HMODULE __stdcall Mine_LoadLibraryExW(LPCWSTR a0,
                                      HANDLE a1,
                                      DWORD a2)
{
    _PrintEnter("LoadLibraryExW(%ls,%lx,%lx)\n", a0, a1, a2);

    HMODULE rv = 0;
    __try {
        rv = Real_LoadLibraryExW(a0, a1, a2);
    } __finally {
        _PrintExit("LoadLibraryExW(,,) -> %lx\n", rv);
    };
    return rv;
}

HMODULE __stdcall Mine_LoadLibraryW(LPCWSTR a0)
{
    _PrintEnter("LoadLibraryW(%ls)\n", a0);

    HMODULE rv = 0;
    __try {
        rv = Real_LoadLibraryW(a0);
    } __finally {
        _PrintExit("LoadLibraryW() -> %lx\n", rv);
    };
    return rv;
}

HMENU __stdcall Mine_LoadMenuA(HINSTANCE a0,
                               LPCSTR a1)
{
    _PrintEnter("LoadMenuA(%lx,%hs)\n", a0, a1);

    HMENU rv = 0;
    __try {
        rv = Real_LoadMenuA(a0, a1);
    } __finally {
        _PrintExit("LoadMenuA(,) -> %lx\n", rv);
    };
    return rv;
}

HMENU __stdcall Mine_LoadMenuIndirectA(MENUTEMPLATEA* a0)
{
    _PrintEnter("LoadMenuIndirectA(%lx)\n", a0);

    HMENU rv = 0;
    __try {
        rv = Real_LoadMenuIndirectA(a0);
    } __finally {
        _PrintExit("LoadMenuIndirectA() -> %lx\n", rv);
    };
    return rv;
}

HMENU __stdcall Mine_LoadMenuIndirectW(MENUTEMPLATEW* a0)
{
    _PrintEnter("LoadMenuIndirectW(%lx)\n", a0);

    HMENU rv = 0;
    __try {
        rv = Real_LoadMenuIndirectW(a0);
    } __finally {
        _PrintExit("LoadMenuIndirectW() -> %lx\n", rv);
    };
    return rv;
}

HMENU __stdcall Mine_LoadMenuW(HINSTANCE a0,
                               LPCWSTR a1)
{
    _PrintEnter("LoadMenuW(%lx,%ls)\n", a0, a1);

    HMENU rv = 0;
    __try {
        rv = Real_LoadMenuW(a0, a1);
    } __finally {
        _PrintExit("LoadMenuW(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_LoadModule(LPCSTR a0,
                                LPVOID a1)
{
    _PrintEnter("LoadModule(%hs,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_LoadModule(a0, a1);
    } __finally {
        _PrintExit("LoadModule(,) -> %lx\n", rv);
    };
    return rv;
}

HGLOBAL __stdcall Mine_LoadResource(HMODULE a0,
                                    HRSRC a1)
{
    _PrintEnter("LoadResource(%lx,%lx)\n", a0, a1);

    HGLOBAL rv = 0;
    __try {
        rv = Real_LoadResource(a0, a1);
    } __finally {
        _PrintExit("LoadResource(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_LoadStringA(HINSTANCE a0,
                               UINT a1,
                               LPSTR a2,
                               int a3)
{
    _PrintEnter("LoadStringA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_LoadStringA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("LoadStringA(,,%hs,) -> %lx\n", a2, rv);
    };
    return rv;
}

int __stdcall Mine_LoadStringW(HINSTANCE a0,
                               UINT a1,
                               LPWSTR a2,
                               int a3)
{
    _PrintEnter("LoadStringW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_LoadStringW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("LoadStringW(,,%ls,) -> %lx\n", a2, rv);
    };
    return rv;
}

HLOCAL __stdcall Mine_LocalAlloc(UINT a0,
                                 SIZE_T a1)
{
    _PrintEnter("LocalAlloc(%lx,%lx)\n", a0, a1);

    HLOCAL rv = 0;
    __try {
        rv = Real_LocalAlloc(a0, a1);
    } __finally {
        _PrintExit("LocalAlloc(,) -> %lx\n", rv);
    };
    return rv;
}

SIZE_T __stdcall Mine_LocalCompact(UINT a0)
{
    _PrintEnter("LocalCompact(%lx)\n", a0);

    SIZE_T rv = 0;
    __try {
        rv = Real_LocalCompact(a0);
    } __finally {
        _PrintExit("LocalCompact() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_LocalFileTimeToFileTime(FILETIME* a0,
                                            LPFILETIME a1)
{
    _PrintEnter("LocalFileTimeToFileTime(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_LocalFileTimeToFileTime(a0, a1);
    } __finally {
        _PrintExit("LocalFileTimeToFileTime(,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_LocalFlags(HLOCAL a0)
{
    _PrintEnter("LocalFlags(%lx)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_LocalFlags(a0);
    } __finally {
        _PrintExit("LocalFlags() -> %lx\n", rv);
    };
    return rv;
}

HLOCAL __stdcall Mine_LocalFree(HLOCAL a0)
{
    _PrintEnter("LocalFree(%lx)\n", a0);

    HLOCAL rv = 0;
    __try {
        rv = Real_LocalFree(a0);
    } __finally {
        _PrintExit("LocalFree() -> %lx\n", rv);
    };
    return rv;
}

HLOCAL __stdcall Mine_LocalHandle(LPCVOID a0)
{
    _PrintEnter("LocalHandle(%lx)\n", a0);

    HLOCAL rv = 0;
    __try {
        rv = Real_LocalHandle(a0);
    } __finally {
        _PrintExit("LocalHandle() -> %lx\n", rv);
    };
    return rv;
}

LPVOID __stdcall Mine_LocalLock(HLOCAL a0)
{
    _PrintEnter("LocalLock(%lx)\n", a0);

    LPVOID rv = 0;
    __try {
        rv = Real_LocalLock(a0);
    } __finally {
        _PrintExit("LocalLock() -> %lx\n", rv);
    };
    return rv;
}

HLOCAL __stdcall Mine_LocalReAlloc(HLOCAL a0,
                                   SIZE_T a1,
                                   UINT a2)
{
    _PrintEnter("LocalReAlloc(%lx,%lx,%lx)\n", a0, a1, a2);

    HLOCAL rv = 0;
    __try {
        rv = Real_LocalReAlloc(a0, a1, a2);
    } __finally {
        _PrintExit("LocalReAlloc(,,) -> %lx\n", rv);
    };
    return rv;
}

SIZE_T __stdcall Mine_LocalShrink(HLOCAL a0,
                                  UINT a1)
{
    _PrintEnter("LocalShrink(%lx,%lx)\n", a0, a1);

    SIZE_T rv = 0;
    __try {
        rv = Real_LocalShrink(a0, a1);
    } __finally {
        _PrintExit("LocalShrink(,) -> %lx\n", rv);
    };
    return rv;
}

SIZE_T __stdcall Mine_LocalSize(HLOCAL a0)
{
    _PrintEnter("LocalSize(%lx)\n", a0);

    SIZE_T rv = 0;
    __try {
        rv = Real_LocalSize(a0);
    } __finally {
        _PrintExit("LocalSize() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_LocalUnlock(HLOCAL a0)
{
    _PrintEnter("LocalUnlock(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_LocalUnlock(a0);
    } __finally {
        _PrintExit("LocalUnlock() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_LockFile(HANDLE a0,
                             DWORD a1,
                             DWORD a2,
                             DWORD a3,
                             DWORD a4)
{
    _PrintEnter("LockFile(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_LockFile(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("LockFile(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_LockFileEx(HANDLE a0,
                               DWORD a1,
                               DWORD a2,
                               DWORD a3,
                               DWORD a4,
                               LPOVERLAPPED a5)
{
    _PrintEnter("LockFileEx(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_LockFileEx(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("LockFileEx(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

LPVOID __stdcall Mine_LockResource(HGLOBAL a0)
{
    _PrintEnter("LockResource(%lx)\n", a0);

    LPVOID rv = 0;
    __try {
        rv = Real_LockResource(a0);
    } __finally {
        _PrintExit("LockResource() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_LockWindowUpdate(HWND a0)
{
    _PrintEnter("LockWindowUpdate(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_LockWindowUpdate(a0);
    } __finally {
        _PrintExit("LockWindowUpdate() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_LookupIconIdFromDirectory(PBYTE a0,
                                             BOOL a1)
{
    _PrintEnter("LookupIconIdFromDirectory(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_LookupIconIdFromDirectory(a0, a1);
    } __finally {
        _PrintExit("LookupIconIdFromDirectory(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_LookupIconIdFromDirectoryEx(PBYTE a0,
                                               BOOL a1,
                                               int a2,
                                               int a3,
                                               UINT a4)
{
    _PrintEnter("LookupIconIdFromDirectoryEx(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_LookupIconIdFromDirectoryEx(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("LookupIconIdFromDirectoryEx(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_MapDialogRect(HWND a0,
                                  LPRECT a1)
{
    _PrintEnter("MapDialogRect(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_MapDialogRect(a0, a1);
    } __finally {
        _PrintExit("MapDialogRect(,) -> %lx\n", rv);
    };
    return rv;
}

LPVOID __stdcall Mine_MapViewOfFile(HANDLE a0,
                                    DWORD a1,
                                    DWORD a2,
                                    DWORD a3,
                                    SIZE_T a4)
{
    _PrintEnter("MapViewOfFile(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    LPVOID rv = 0;
    __try {
        rv = Real_MapViewOfFile(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("MapViewOfFile(,,,,) -> %lx\n", rv);
    };
    return rv;
}

LPVOID __stdcall Mine_MapViewOfFileEx(HANDLE a0,
                                      DWORD a1,
                                      DWORD a2,
                                      DWORD a3,
                                      SIZE_T a4,
                                      LPVOID a5)
{
    _PrintEnter("MapViewOfFileEx(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    LPVOID rv = 0;
    __try {
        rv = Real_MapViewOfFileEx(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("MapViewOfFileEx(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_MapVirtualKeyA(UINT a0,
                                   UINT a1)
{
    _PrintEnter("MapVirtualKeyA(%lx,%lx)\n", a0, a1);

    UINT rv = 0;
    __try {
        rv = Real_MapVirtualKeyA(a0, a1);
    } __finally {
        _PrintExit("MapVirtualKeyA(,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_MapVirtualKeyExA(UINT a0,
                                     UINT a1,
                                     HKL a2)
{
    _PrintEnter("MapVirtualKeyExA(%lx,%lx,%lx)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_MapVirtualKeyExA(a0, a1, a2);
    } __finally {
        _PrintExit("MapVirtualKeyExA(,,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_MapVirtualKeyExW(UINT a0,
                                     UINT a1,
                                     HKL a2)
{
    _PrintEnter("MapVirtualKeyExW(%lx,%lx,%lx)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_MapVirtualKeyExW(a0, a1, a2);
    } __finally {
        _PrintExit("MapVirtualKeyExW(,,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_MapVirtualKeyW(UINT a0,
                                   UINT a1)
{
    _PrintEnter("MapVirtualKeyW(%lx,%lx)\n", a0, a1);

    UINT rv = 0;
    __try {
        rv = Real_MapVirtualKeyW(a0, a1);
    } __finally {
        _PrintExit("MapVirtualKeyW(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_MapWindowPoints(HWND a0,
                                   HWND a1,
                                   struct tagPOINT* a2,
                                   UINT a3)
{
    _PrintEnter("MapWindowPoints(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_MapWindowPoints(a0, a1, a2, a3);
    } __finally {
        _PrintExit("MapWindowPoints(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_MaskBlt(HDC a0,
                            int a1,
                            int a2,
                            int a3,
                            int a4,
                            HDC a5,
                            int a6,
                            int a7,
                            HBITMAP a8,
                            int a9,
                            int a10,
                            DWORD a11)
{
    _PrintEnter("MaskBlt(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);

    BOOL rv = 0;
    __try {
        rv = Real_MaskBlt(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
    } __finally {
        _PrintExit("MaskBlt(,,,,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_MenuItemFromPoint(HWND a0,
                                     HMENU a1,
                                     POINT a2)
{
    _PrintEnter("MenuItemFromPoint(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_MenuItemFromPoint(a0, a1, a2);
    } __finally {
        _PrintExit("MenuItemFromPoint(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_MessageBeep(UINT a0)
{
    _PrintEnter("MessageBeep(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_MessageBeep(a0);
    } __finally {
        _PrintExit("MessageBeep() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_MessageBoxA(HWND a0,
                               LPCSTR a1,
                               LPCSTR a2,
                               UINT a3)
{
    _PrintEnter("MessageBoxA(%lx,%hs,%hs,%lx)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_MessageBoxA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("MessageBoxA(,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_MessageBoxExA(HWND a0,
                                 LPCSTR a1,
                                 LPCSTR a2,
                                 UINT a3,
                                 WORD a4)
{
    _PrintEnter("MessageBoxExA(%lx,%hs,%hs,%lx,%lx)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_MessageBoxExA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("MessageBoxExA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_MessageBoxExW(HWND a0,
                                 LPCWSTR a1,
                                 LPCWSTR a2,
                                 UINT a3,
                                 WORD a4)
{
    _PrintEnter("MessageBoxExW(%lx,%ls,%ls,%lx,%lx)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_MessageBoxExW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("MessageBoxExW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_MessageBoxIndirectA(struct tagMSGBOXPARAMSA* a0)
{
    _PrintEnter("MessageBoxIndirectA(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_MessageBoxIndirectA(a0);
    } __finally {
        _PrintExit("MessageBoxIndirectA() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_MessageBoxIndirectW(struct tagMSGBOXPARAMSW* a0)
{
    _PrintEnter("MessageBoxIndirectW(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_MessageBoxIndirectW(a0);
    } __finally {
        _PrintExit("MessageBoxIndirectW() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_MessageBoxW(HWND a0,
                               LPCWSTR a1,
                               LPCWSTR a2,
                               UINT a3)
{
    _PrintEnter("MessageBoxW(%lx,%ls,%ls,%lx)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_MessageBoxW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("MessageBoxW(,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_MkParseDisplayName(struct IBindCtx* a0,
                                          LPCOLESTR a1,
                                          ULONG* a2,
                                          struct IMoniker** a3)
{
    _PrintEnter("MkParseDisplayName(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_MkParseDisplayName(a0, a1, a2, a3);
    } __finally {
        _PrintExit("MkParseDisplayName(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ModifyMenuA(HMENU a0,
                                UINT a1,
                                UINT a2,
                                UINT_PTR a3,
                                LPCSTR a4)
{
    _PrintEnter("ModifyMenuA(%lx,%lx,%lx,%lx,%hs)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ModifyMenuA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ModifyMenuA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ModifyMenuW(HMENU a0,
                                UINT a1,
                                UINT a2,
                                UINT_PTR a3,
                                LPCWSTR a4)
{
    _PrintEnter("ModifyMenuW(%lx,%lx,%lx,%lx,%ls)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ModifyMenuW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ModifyMenuW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ModifyWorldTransform(HDC a0,
                                         XFORM* a1,
                                         DWORD a2)
{
    _PrintEnter("ModifyWorldTransform(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_ModifyWorldTransform(a0, a1, a2);
    } __finally {
        _PrintExit("ModifyWorldTransform(,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_MonikerCommonPrefixWith(struct IMoniker* a0,
                                               struct IMoniker* a1,
                                               struct IMoniker** a2)
{
    _PrintEnter("MonikerCommonPrefixWith(%lx,%lx,%lx)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_MonikerCommonPrefixWith(a0, a1, a2);
    } __finally {
        _PrintExit("MonikerCommonPrefixWith(,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_MonikerRelativePathTo(struct IMoniker* a0,
                                             struct IMoniker* a1,
                                             struct IMoniker** a2,
                                             BOOL a3)
{
    _PrintEnter("MonikerRelativePathTo(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_MonikerRelativePathTo(a0, a1, a2, a3);
    } __finally {
        _PrintExit("MonikerRelativePathTo(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_MoveFileA(LPCSTR a0,
                              LPCSTR a1)
{
    _PrintEnter("MoveFileA(%hs,%hs)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_MoveFileA(a0, a1);
    } __finally {
        _PrintExit("MoveFileA(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_MoveFileExA(LPCSTR a0,
                                LPCSTR a1,
                                DWORD a2)
{
    _PrintEnter("MoveFileExA(%hs,%hs,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_MoveFileExA(a0, a1, a2);
    } __finally {
        _PrintExit("MoveFileExA(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_MoveFileExW(LPCWSTR a0,
                                LPCWSTR a1,
                                DWORD a2)
{
    _PrintEnter("MoveFileExW(%ls,%ls,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_MoveFileExW(a0, a1, a2);
    } __finally {
        _PrintExit("MoveFileExW(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_MoveFileW(LPCWSTR a0,
                              LPCWSTR a1)
{
    _PrintEnter("MoveFileW(%ls,%ls)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_MoveFileW(a0, a1);
    } __finally {
        _PrintExit("MoveFileW(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_MoveToEx(HDC a0,
                             int a1,
                             int a2,
                             struct tagPOINT* a3)
{
    _PrintEnter("MoveToEx(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_MoveToEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("MoveToEx(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_MoveWindow(HWND a0,
                               int a1,
                               int a2,
                               int a3,
                               int a4,
                               BOOL a5)
{
    _PrintEnter("MoveWindow(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_MoveWindow(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("MoveWindow(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_MsgWaitForMultipleObjects(DWORD a0,
                                               void** a1,
                                               BOOL a2,
                                               DWORD a3,
                                               DWORD a4)
{
    _PrintEnter("MsgWaitForMultipleObjects(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_MsgWaitForMultipleObjects(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("MsgWaitForMultipleObjects(,,,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_MsgWaitForMultipleObjectsEx(DWORD a0,
                                                 void** a1,
                                                 DWORD a2,
                                                 DWORD a3,
                                                 DWORD a4)
{
    _PrintEnter("MsgWaitForMultipleObjectsEx(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_MsgWaitForMultipleObjectsEx(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("MsgWaitForMultipleObjectsEx(,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_MulDiv(int a0,
                          int a1,
                          int a2)
{
    _PrintEnter("MulDiv(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_MulDiv(a0, a1, a2);
    } __finally {
        _PrintExit("MulDiv(,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_OemKeyScan(WORD a0)
{
    _PrintEnter("OemKeyScan(%lx)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_OemKeyScan(a0);
    } __finally {
        _PrintExit("OemKeyScan() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_OemToCharA(LPCSTR a0,
                               LPSTR a1)
{
    _PrintEnter("OemToCharA(%hs,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_OemToCharA(a0, a1);
    } __finally {
        _PrintExit("OemToCharA(,%hs) -> %lx\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_OemToCharBuffA(LPCSTR a0,
                                   LPSTR a1,
                                   DWORD a2)
{
    _PrintEnter("OemToCharBuffA(%hs,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_OemToCharBuffA(a0, a1, a2);
    } __finally {
        _PrintExit("OemToCharBuffA(,%hs,) -> %lx\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_OemToCharBuffW(LPCSTR a0,
                                   LPWSTR a1,
                                   DWORD a2)
{
    _PrintEnter("OemToCharBuffW(%hs,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_OemToCharBuffW(a0, a1, a2);
    } __finally {
        _PrintExit("OemToCharBuffW(,%ls,) -> %lx\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_OemToCharW(LPCSTR a0,
                               LPWSTR a1)
{
    _PrintEnter("OemToCharW(%hs,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_OemToCharW(a0, a1);
    } __finally {
        _PrintExit("OemToCharW(,%ls) -> %lx\n", a1, rv);
    };
    return rv;
}

int __stdcall Mine_OffsetClipRgn(HDC a0,
                                 int a1,
                                 int a2)
{
    _PrintEnter("OffsetClipRgn(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_OffsetClipRgn(a0, a1, a2);
    } __finally {
        _PrintExit("OffsetClipRgn(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_OffsetRect(LPRECT a0,
                               int a1,
                               int a2)
{
    _PrintEnter("OffsetRect(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_OffsetRect(a0, a1, a2);
    } __finally {
        _PrintExit("OffsetRect(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_OffsetRgn(HRGN a0,
                             int a1,
                             int a2)
{
    _PrintEnter("OffsetRgn(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_OffsetRgn(a0, a1, a2);
    } __finally {
        _PrintExit("OffsetRgn(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_OffsetViewportOrgEx(HDC a0,
                                        int a1,
                                        int a2,
                                        struct tagPOINT* a3)
{
    _PrintEnter("OffsetViewportOrgEx(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_OffsetViewportOrgEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("OffsetViewportOrgEx(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_OffsetWindowOrgEx(HDC a0,
                                      int a1,
                                      int a2,
                                      struct tagPOINT* a3)
{
    _PrintEnter("OffsetWindowOrgEx(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_OffsetWindowOrgEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("OffsetWindowOrgEx(,,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_OleBuildVersion(void)
{
    _PrintEnter("OleBuildVersion()\n");

    DWORD rv = 0;
    __try {
        rv = Real_OleBuildVersion();
    } __finally {
        _PrintExit("OleBuildVersion() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleConvertIStorageToOLESTREAM(struct IStorage* a0,
                                                     LPOLESTREAM a1)
{
    _PrintEnter("OleConvertIStorageToOLESTREAM(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_OleConvertIStorageToOLESTREAM(a0, a1);
    } __finally {
        _PrintExit("OleConvertIStorageToOLESTREAM(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleConvertIStorageToOLESTREAMEx(struct IStorage* a0,
                                                       CLIPFORMAT a1,
                                                       LONG a2,
                                                       LONG a3,
                                                       DWORD a4,
                                                       LPSTGMEDIUM a5,
                                                       LPOLESTREAM a6)
{
    _PrintEnter("OleConvertIStorageToOLESTREAMEx(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    HRESULT rv = 0;
    __try {
        rv = Real_OleConvertIStorageToOLESTREAMEx(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("OleConvertIStorageToOLESTREAMEx(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleConvertOLESTREAMToIStorage(LPOLESTREAM a0,
                                                     struct IStorage* a1,
                                                     DVTARGETDEVICE* a2)
{
    _PrintEnter("OleConvertOLESTREAMToIStorage(%lx,%lx,%lx)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_OleConvertOLESTREAMToIStorage(a0, a1, a2);
    } __finally {
        _PrintExit("OleConvertOLESTREAMToIStorage(,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleConvertOLESTREAMToIStorageEx(LPOLESTREAM a0,
                                                       struct IStorage* a1,
                                                       CLIPFORMAT* a2,
                                                       LONG* a3,
                                                       LONG* a4,
                                                       DWORD* a5,
                                                       LPSTGMEDIUM a6)
{
    _PrintEnter("OleConvertOLESTREAMToIStorageEx(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    HRESULT rv = 0;
    __try {
        rv = Real_OleConvertOLESTREAMToIStorageEx(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("OleConvertOLESTREAMToIStorageEx(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreate(IID& a0,
                                 IID& a1,
                                 DWORD a2,
                                 LPFORMATETC a3,
                                 LPOLECLIENTSITE a4,
                                 struct IStorage* a5,
                                 LPVOID* a6)
{
    _PrintEnter("OleCreate(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreate(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("OleCreate(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateDefaultHandler(IID& a0,
                                               LPUNKNOWN a1,
                                               IID& a2,
                                               LPVOID* a3)
{
    _PrintEnter("OleCreateDefaultHandler(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateDefaultHandler(a0, a1, a2, a3);
    } __finally {
        _PrintExit("OleCreateDefaultHandler(,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateEmbeddingHelper(IID& a0,
                                                LPUNKNOWN a1,
                                                DWORD a2,
                                                LPCLASSFACTORY a3,
                                                IID& a4,
                                                LPVOID* a5)
{
    _PrintEnter("OleCreateEmbeddingHelper(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateEmbeddingHelper(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("OleCreateEmbeddingHelper(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateEx(IID& a0,
                                   IID& a1,
                                   DWORD a2,
                                   DWORD a3,
                                   ULONG a4,
                                   DWORD* a5,
                                   LPFORMATETC a6,
                                   IAdviseSink* a7,
                                   DWORD* a8,
                                   LPOLECLIENTSITE a9,
                                   struct IStorage* a10,
                                   LPVOID* a11)
{
    _PrintEnter("OleCreateEx(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateEx(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
    } __finally {
        _PrintExit("OleCreateEx(,,,,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateFromData(struct IDataObject* a0,
                                         IID& a1,
                                         DWORD a2,
                                         LPFORMATETC a3,
                                         LPOLECLIENTSITE a4,
                                         struct IStorage* a5,
                                         LPVOID* a6)
{
    _PrintEnter("OleCreateFromData(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateFromData(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("OleCreateFromData(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateFromDataEx(struct IDataObject* a0,
                                           IID& a1,
                                           DWORD a2,
                                           DWORD a3,
                                           ULONG a4,
                                           DWORD* a5,
                                           LPFORMATETC a6,
                                           IAdviseSink* a7,
                                           DWORD* a8,
                                           LPOLECLIENTSITE a9,
                                           struct IStorage* a10,
                                           LPVOID* a11)
{
    _PrintEnter("OleCreateFromDataEx(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateFromDataEx(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
    } __finally {
        _PrintExit("OleCreateFromDataEx(,,,,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateFromFile(IID& a0,
                                         LPCOLESTR a1,
                                         IID& a2,
                                         DWORD a3,
                                         LPFORMATETC a4,
                                         LPOLECLIENTSITE a5,
                                         struct IStorage* a6,
                                         LPVOID* a7)
{
    _PrintEnter("OleCreateFromFile(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateFromFile(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("OleCreateFromFile(,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateFromFileEx(IID& a0,
                                           LPCOLESTR a1,
                                           IID& a2,
                                           DWORD a3,
                                           DWORD a4,
                                           ULONG a5,
                                           DWORD* a6,
                                           LPFORMATETC a7,
                                           IAdviseSink* a8,
                                           DWORD* a9,
                                           LPOLECLIENTSITE a10,
                                           struct IStorage* a11,
                                           LPVOID* a12)
{
    _PrintEnter("OleCreateFromFileEx(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateFromFileEx(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
    } __finally {
        _PrintExit("OleCreateFromFileEx(,,,,,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateLink(struct IMoniker* a0,
                                     IID& a1,
                                     DWORD a2,
                                     LPFORMATETC a3,
                                     LPOLECLIENTSITE a4,
                                     struct IStorage* a5,
                                     LPVOID* a6)
{
    _PrintEnter("OleCreateLink(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateLink(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("OleCreateLink(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateLinkEx(struct IMoniker* a0,
                                       IID& a1,
                                       DWORD a2,
                                       DWORD a3,
                                       ULONG a4,
                                       DWORD* a5,
                                       LPFORMATETC a6,
                                       IAdviseSink* a7,
                                       DWORD* a8,
                                       LPOLECLIENTSITE a9,
                                       struct IStorage* a10,
                                       LPVOID* a11)
{
    _PrintEnter("OleCreateLinkEx(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateLinkEx(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
    } __finally {
        _PrintExit("OleCreateLinkEx(,,,,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateLinkFromData(struct IDataObject* a0,
                                             IID& a1,
                                             DWORD a2,
                                             LPFORMATETC a3,
                                             LPOLECLIENTSITE a4,
                                             struct IStorage* a5,
                                             LPVOID* a6)
{
    _PrintEnter("OleCreateLinkFromData(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateLinkFromData(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("OleCreateLinkFromData(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateLinkFromDataEx(struct IDataObject* a0,
                                               IID& a1,
                                               DWORD a2,
                                               DWORD a3,
                                               ULONG a4,
                                               DWORD* a5,
                                               LPFORMATETC a6,
                                               IAdviseSink* a7,
                                               DWORD* a8,
                                               LPOLECLIENTSITE a9,
                                               struct IStorage* a10,
                                               LPVOID* a11)
{
    _PrintEnter("OleCreateLinkFromDataEx(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateLinkFromDataEx(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
    } __finally {
        _PrintExit("OleCreateLinkFromDataEx(,,,,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateLinkToFile(LPCOLESTR a0,
                                           IID& a1,
                                           DWORD a2,
                                           LPFORMATETC a3,
                                           LPOLECLIENTSITE a4,
                                           struct IStorage* a5,
                                           LPVOID* a6)
{
    _PrintEnter("OleCreateLinkToFile(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateLinkToFile(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("OleCreateLinkToFile(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateLinkToFileEx(LPCOLESTR a0,
                                             IID& a1,
                                             DWORD a2,
                                             DWORD a3,
                                             ULONG a4,
                                             DWORD* a5,
                                             LPFORMATETC a6,
                                             IAdviseSink* a7,
                                             DWORD* a8,
                                             LPOLECLIENTSITE a9,
                                             struct IStorage* a10,
                                             LPVOID* a11)
{
    _PrintEnter("OleCreateLinkToFileEx(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateLinkToFileEx(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
    } __finally {
        _PrintExit("OleCreateLinkToFileEx(,,,,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HOLEMENU __stdcall Mine_OleCreateMenuDescriptor(HMENU a0,
                                                LPOLEMENUGROUPWIDTHS a1)
{
    _PrintEnter("OleCreateMenuDescriptor(%lx,%lx)\n", a0, a1);

    HOLEMENU rv = 0;
    __try {
        rv = Real_OleCreateMenuDescriptor(a0, a1);
    } __finally {
        _PrintExit("OleCreateMenuDescriptor(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleCreateStaticFromData(struct IDataObject* a0,
                                               IID& a1,
                                               DWORD a2,
                                               LPFORMATETC a3,
                                               LPOLECLIENTSITE a4,
                                               struct IStorage* a5,
                                               LPVOID* a6)
{
    _PrintEnter("OleCreateStaticFromData(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    HRESULT rv = 0;
    __try {
        rv = Real_OleCreateStaticFromData(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("OleCreateStaticFromData(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleDestroyMenuDescriptor(HOLEMENU a0)
{
    _PrintEnter("OleDestroyMenuDescriptor(%lx)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_OleDestroyMenuDescriptor(a0);
    } __finally {
        _PrintExit("OleDestroyMenuDescriptor() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleDoAutoConvert(struct IStorage* a0,
                                        struct _GUID* a1)
{
    _PrintEnter("OleDoAutoConvert(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_OleDoAutoConvert(a0, a1);
    } __finally {
        _PrintExit("OleDoAutoConvert(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleDraw(LPUNKNOWN a0,
                               DWORD a1,
                               HDC a2,
                               LPCRECT a3)
{
    _PrintEnter("OleDraw(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_OleDraw(a0, a1, a2, a3);
    } __finally {
        _PrintExit("OleDraw(,,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_OleDuplicateData(HANDLE a0,
                                       CLIPFORMAT a1,
                                       UINT a2)
{
    _PrintEnter("OleDuplicateData(%lx,%lx,%lx)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_OleDuplicateData(a0, a1, a2);
    } __finally {
        _PrintExit("OleDuplicateData(,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleFlushClipboard(void)
{
    _PrintEnter("OleFlushClipboard()\n");

    HRESULT rv = 0;
    __try {
        rv = Real_OleFlushClipboard();
    } __finally {
        _PrintExit("OleFlushClipboard() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleGetAutoConvert(IID& a0,
                                         struct _GUID* a1)
{
    _PrintEnter("OleGetAutoConvert(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_OleGetAutoConvert(a0, a1);
    } __finally {
        _PrintExit("OleGetAutoConvert(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleGetClipboard(struct IDataObject** a0)
{
    _PrintEnter("OleGetClipboard(%lx)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_OleGetClipboard(a0);
    } __finally {
        _PrintExit("OleGetClipboard() -> %lx\n", rv);
    };
    return rv;
}

HGLOBAL __stdcall Mine_OleGetIconOfClass(IID& a0,
                                         LPOLESTR a1,
                                         BOOL a2)
{
    _PrintEnter("OleGetIconOfClass(%lx,%lx,%lx)\n", a0, a1, a2);

    HGLOBAL rv = 0;
    __try {
        rv = Real_OleGetIconOfClass(a0, a1, a2);
    } __finally {
        _PrintExit("OleGetIconOfClass(,,) -> %lx\n", rv);
    };
    return rv;
}

HGLOBAL __stdcall Mine_OleGetIconOfFile(LPOLESTR a0,
                                        BOOL a1)
{
    _PrintEnter("OleGetIconOfFile(%lx,%lx)\n", a0, a1);

    HGLOBAL rv = 0;
    __try {
        rv = Real_OleGetIconOfFile(a0, a1);
    } __finally {
        _PrintExit("OleGetIconOfFile(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleInitialize(LPVOID a0)
{
    _PrintEnter("OleInitialize(%lx)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_OleInitialize(a0);
    } __finally {
        _PrintExit("OleInitialize() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleIsCurrentClipboard(struct IDataObject* a0)
{
    _PrintEnter("OleIsCurrentClipboard(%lx)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_OleIsCurrentClipboard(a0);
    } __finally {
        _PrintExit("OleIsCurrentClipboard() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_OleIsRunning(struct IOleObject* a0)
{
    _PrintEnter("OleIsRunning(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_OleIsRunning(a0);
    } __finally {
        _PrintExit("OleIsRunning() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleLoad(struct IStorage* a0,
                               IID& a1,
                               LPOLECLIENTSITE a2,
                               LPVOID* a3)
{
    _PrintEnter("OleLoad(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_OleLoad(a0, a1, a2, a3);
    } __finally {
        _PrintExit("OleLoad(,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleLoadFromStream(LPSTREAM a0,
                                         IID& a1,
                                         LPVOID* a2)
{
    _PrintEnter("OleLoadFromStream(%lx,%lx,%lx)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_OleLoadFromStream(a0, a1, a2);
    } __finally {
        _PrintExit("OleLoadFromStream(,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleLockRunning(LPUNKNOWN a0,
                                      BOOL a1,
                                      BOOL a2)
{
    _PrintEnter("OleLockRunning(%lx,%lx,%lx)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_OleLockRunning(a0, a1, a2);
    } __finally {
        _PrintExit("OleLockRunning(,,) -> %lx\n", rv);
    };
    return rv;
}

HGLOBAL __stdcall Mine_OleMetafilePictFromIconAndLabel(HICON a0,
                                                       LPOLESTR a1,
                                                       LPOLESTR a2,
                                                       UINT a3)
{
    _PrintEnter("OleMetafilePictFromIconAndLabel(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HGLOBAL rv = 0;
    __try {
        rv = Real_OleMetafilePictFromIconAndLabel(a0, a1, a2, a3);
    } __finally {
        _PrintExit("OleMetafilePictFromIconAndLabel(,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleNoteObjectVisible(LPUNKNOWN a0,
                                            BOOL a1)
{
    _PrintEnter("OleNoteObjectVisible(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_OleNoteObjectVisible(a0, a1);
    } __finally {
        _PrintExit("OleNoteObjectVisible(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleQueryCreateFromData(struct IDataObject* a0)
{
    _PrintEnter("OleQueryCreateFromData(%lx)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_OleQueryCreateFromData(a0);
    } __finally {
        _PrintExit("OleQueryCreateFromData() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleQueryLinkFromData(struct IDataObject* a0)
{
    _PrintEnter("OleQueryLinkFromData(%lx)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_OleQueryLinkFromData(a0);
    } __finally {
        _PrintExit("OleQueryLinkFromData() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleRegEnumFormatEtc(IID& a0,
                                           DWORD a1,
                                           struct IEnumFORMATETC** a2)
{
    _PrintEnter("OleRegEnumFormatEtc(%lx,%lx,%lx)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_OleRegEnumFormatEtc(a0, a1, a2);
    } __finally {
        _PrintExit("OleRegEnumFormatEtc(,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleRegEnumVerbs(IID& a0,
                                       struct IEnumOLEVERB** a1)
{
    _PrintEnter("OleRegEnumVerbs(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_OleRegEnumVerbs(a0, a1);
    } __finally {
        _PrintExit("OleRegEnumVerbs(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleRegGetMiscStatus(IID& a0,
                                           DWORD a1,
                                           DWORD* a2)
{
    _PrintEnter("OleRegGetMiscStatus(%lx,%lx,%lx)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_OleRegGetMiscStatus(a0, a1, a2);
    } __finally {
        _PrintExit("OleRegGetMiscStatus(,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleRegGetUserType(IID& a0,
                                         DWORD a1,
                                         LPOLESTR* a2)
{
    _PrintEnter("OleRegGetUserType(%lx,%lx,%lx)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_OleRegGetUserType(a0, a1, a2);
    } __finally {
        _PrintExit("OleRegGetUserType(,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleRun(LPUNKNOWN a0)
{
    _PrintEnter("OleRun(%lx)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_OleRun(a0);
    } __finally {
        _PrintExit("OleRun() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleSave(LPPERSISTSTORAGE a0,
                               struct IStorage* a1,
                               BOOL a2)
{
    _PrintEnter("OleSave(%lx,%lx,%lx)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_OleSave(a0, a1, a2);
    } __finally {
        _PrintExit("OleSave(,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleSaveToStream(struct IPersistStream* a0,
                                       LPSTREAM a1)
{
    _PrintEnter("OleSaveToStream(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_OleSaveToStream(a0, a1);
    } __finally {
        _PrintExit("OleSaveToStream(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleSetAutoConvert(IID& a0,
                                         IID& a1)
{
    _PrintEnter("OleSetAutoConvert(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_OleSetAutoConvert(a0, a1);
    } __finally {
        _PrintExit("OleSetAutoConvert(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleSetClipboard(struct IDataObject* a0)
{
    _PrintEnter("OleSetClipboard(%lx)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_OleSetClipboard(a0);
    } __finally {
        _PrintExit("OleSetClipboard() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleSetContainedObject(LPUNKNOWN a0,
                                             BOOL a1)
{
    _PrintEnter("OleSetContainedObject(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_OleSetContainedObject(a0, a1);
    } __finally {
        _PrintExit("OleSetContainedObject(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleSetMenuDescriptor(HOLEMENU a0,
                                            HWND a1,
                                            HWND a2,
                                            LPOLEINPLACEFRAME a3,
                                            LPOLEINPLACEACTIVEOBJECT a4)
{
    _PrintEnter("OleSetMenuDescriptor(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    HRESULT rv = 0;
    __try {
        rv = Real_OleSetMenuDescriptor(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("OleSetMenuDescriptor(,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_OleTranslateAccelerator(LPOLEINPLACEFRAME a0,
                                               LPOLEINPLACEFRAMEINFO a1,
                                               LPMSG a2)
{
    _PrintEnter("OleTranslateAccelerator(%lx,%lx,%lx)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_OleTranslateAccelerator(a0, a1, a2);
    } __finally {
        _PrintExit("OleTranslateAccelerator(,,) -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_OleUninitialize(void)
{
    _PrintEnter("OleUninitialize()\n");

    __try {
        Real_OleUninitialize();
    } __finally {
        _PrintExit("OleUninitialize() ->\n");
    };
}

BOOL __stdcall Mine_OpenClipboard(HWND a0)
{
    _PrintEnter("OpenClipboard(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_OpenClipboard(a0);
    } __finally {
        _PrintExit("OpenClipboard() -> %lx\n", rv);
    };
    return rv;
}

HDESK __stdcall Mine_OpenDesktopA(LPCSTR a0,
                                  DWORD a1,
                                  BOOL a2,
                                  ACCESS_MASK a3)
{
    _PrintEnter("OpenDesktopA(%hs,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HDESK rv = 0;
    __try {
        rv = Real_OpenDesktopA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("OpenDesktopA(,,,) -> %lx\n", rv);
    };
    return rv;
}

HDESK __stdcall Mine_OpenDesktopW(LPCWSTR a0,
                                  DWORD a1,
                                  BOOL a2,
                                  ACCESS_MASK a3)
{
    _PrintEnter("OpenDesktopW(%ls,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HDESK rv = 0;
    __try {
        rv = Real_OpenDesktopW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("OpenDesktopW(,,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_OpenEventA(DWORD a0,
                                 BOOL a1,
                                 LPCSTR a2)
{
    _PrintEnter("OpenEventA(%lx,%lx,%hs)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_OpenEventA(a0, a1, a2);
    } __finally {
        _PrintExit("OpenEventA(,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_OpenEventW(DWORD a0,
                                 BOOL a1,
                                 LPCWSTR a2)
{
    _PrintEnter("OpenEventW(%lx,%lx,%ls)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_OpenEventW(a0, a1, a2);
    } __finally {
        _PrintExit("OpenEventW(,,) -> %lx\n", rv);
    };
    return rv;
}

HFILE __stdcall Mine_OpenFile(LPCSTR a0,
                              struct _OFSTRUCT* a1,
                              UINT a2)
{
    _PrintEnter("OpenFile(%hs,%lx,%lx)\n", a0, a1, a2);

    HFILE rv = 0;
    __try {
        rv = Real_OpenFile(a0, a1, a2);
    } __finally {
        _PrintExit("OpenFile(,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_OpenFileMappingA(DWORD a0,
                                       BOOL a1,
                                       LPCSTR a2)
{
    _PrintEnter("OpenFileMappingA(%lx,%lx,%hs)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_OpenFileMappingA(a0, a1, a2);
    } __finally {
        _PrintExit("OpenFileMappingA(,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_OpenFileMappingW(DWORD a0,
                                       BOOL a1,
                                       LPCWSTR a2)
{
    _PrintEnter("OpenFileMappingW(%lx,%lx,%ls)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_OpenFileMappingW(a0, a1, a2);
    } __finally {
        _PrintExit("OpenFileMappingW(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_OpenIcon(HWND a0)
{
    _PrintEnter("OpenIcon(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_OpenIcon(a0);
    } __finally {
        _PrintExit("OpenIcon() -> %lx\n", rv);
    };
    return rv;
}

HDESK __stdcall Mine_OpenInputDesktop(DWORD a0,
                                      BOOL a1,
                                      ACCESS_MASK a2)
{
    _PrintEnter("OpenInputDesktop(%lx,%lx,%lx)\n", a0, a1, a2);

    HDESK rv = 0;
    __try {
        rv = Real_OpenInputDesktop(a0, a1, a2);
    } __finally {
        _PrintExit("OpenInputDesktop(,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_OpenMutexA(DWORD a0,
                                 BOOL a1,
                                 LPCSTR a2)
{
    _PrintEnter("OpenMutexA(%lx,%lx,%hs)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_OpenMutexA(a0, a1, a2);
    } __finally {
        _PrintExit("OpenMutexA(,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_OpenMutexW(DWORD a0,
                                 BOOL a1,
                                 LPCWSTR a2)
{
    _PrintEnter("OpenMutexW(%lx,%lx,%ls)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_OpenMutexW(a0, a1, a2);
    } __finally {
        _PrintExit("OpenMutexW(,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_OpenProcess(DWORD a0,
                                  BOOL a1,
                                  DWORD a2)
{
    _PrintEnter("OpenProcess(%lx,%lx,%lx)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_OpenProcess(a0, a1, a2);
    } __finally {
        _PrintExit("OpenProcess(,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_OpenSemaphoreA(DWORD a0,
                                     BOOL a1,
                                     LPCSTR a2)
{
    _PrintEnter("OpenSemaphoreA(%lx,%lx,%hs)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_OpenSemaphoreA(a0, a1, a2);
    } __finally {
        _PrintExit("OpenSemaphoreA(,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_OpenSemaphoreW(DWORD a0,
                                     BOOL a1,
                                     LPCWSTR a2)
{
    _PrintEnter("OpenSemaphoreW(%lx,%lx,%ls)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_OpenSemaphoreW(a0, a1, a2);
    } __finally {
        _PrintExit("OpenSemaphoreW(,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_OpenWaitableTimerA(DWORD a0,
                                         BOOL a1,
                                         LPCSTR a2)
{
    _PrintEnter("OpenWaitableTimerA(%lx,%lx,%hs)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_OpenWaitableTimerA(a0, a1, a2);
    } __finally {
        _PrintExit("OpenWaitableTimerA(,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_OpenWaitableTimerW(DWORD a0,
                                         BOOL a1,
                                         LPCWSTR a2)
{
    _PrintEnter("OpenWaitableTimerW(%lx,%lx,%ls)\n", a0, a1, a2);

    HANDLE rv = 0;
    __try {
        rv = Real_OpenWaitableTimerW(a0, a1, a2);
    } __finally {
        _PrintExit("OpenWaitableTimerW(,,) -> %lx\n", rv);
    };
    return rv;
}

HWINSTA __stdcall Mine_OpenWindowStationA(LPCSTR a0,
                                          BOOL a1,
                                          ACCESS_MASK a2)
{
    _PrintEnter("OpenWindowStationA(%hs,%lx,%lx)\n", a0, a1, a2);

    HWINSTA rv = 0;
    __try {
        rv = Real_OpenWindowStationA(a0, a1, a2);
    } __finally {
        _PrintExit("OpenWindowStationA(,,) -> %lx\n", rv);
    };
    return rv;
}

HWINSTA __stdcall Mine_OpenWindowStationW(LPCWSTR a0,
                                          BOOL a1,
                                          ACCESS_MASK a2)
{
    _PrintEnter("OpenWindowStationW(%ls,%lx,%lx)\n", a0, a1, a2);

    HWINSTA rv = 0;
    __try {
        rv = Real_OpenWindowStationW(a0, a1, a2);
    } __finally {
        _PrintExit("OpenWindowStationW(,,) -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_OutputDebugStringA(LPCSTR a0)
{
    _PrintEnter("OutputDebugStringA(%hs)\n", a0);

    __try {
        Real_OutputDebugStringA(a0);
    } __finally {
        _PrintExit("OutputDebugStringA() ->\n");
    };
}

void __stdcall Mine_OutputDebugStringW(LPCWSTR a0)
{
    _PrintEnter("OutputDebugStringW(%ls)\n", a0);

    __try {
        Real_OutputDebugStringW(a0);
    } __finally {
        _PrintExit("OutputDebugStringW() ->\n");
    };
}

LPARAM __stdcall Mine_PackDDElParam(UINT a0,
                                    UINT_PTR a1,
                                    UINT_PTR a2)
{
    _PrintEnter("PackDDElParam(%lx,%lx,%lx)\n", a0, a1, a2);

    LPARAM rv = 0;
    __try {
        rv = Real_PackDDElParam(a0, a1, a2);
    } __finally {
        _PrintExit("PackDDElParam(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PaintDesktop(HDC a0)
{
    _PrintEnter("PaintDesktop(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_PaintDesktop(a0);
    } __finally {
        _PrintExit("PaintDesktop() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PaintRgn(HDC a0,
                             HRGN a1)
{
    _PrintEnter("PaintRgn(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_PaintRgn(a0, a1);
    } __finally {
        _PrintExit("PaintRgn(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PatBlt(HDC a0,
                           int a1,
                           int a2,
                           int a3,
                           int a4,
                           DWORD a5)
{
    _PrintEnter("PatBlt(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_PatBlt(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("PatBlt(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRGN __stdcall Mine_PathToRegion(HDC a0)
{
    _PrintEnter("PathToRegion(%lx)\n", a0);

    HRGN rv = 0;
    __try {
        rv = Real_PathToRegion(a0);
    } __finally {
        _PrintExit("PathToRegion() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PeekConsoleInputA(HANDLE a0,
                                      PINPUT_RECORD a1,
                                      DWORD a2,
                                      LPDWORD a3)
{
    _PrintEnter("PeekConsoleInputA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_PeekConsoleInputA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("PeekConsoleInputA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PeekConsoleInputW(HANDLE a0,
                                      PINPUT_RECORD a1,
                                      DWORD a2,
                                      LPDWORD a3)
{
    _PrintEnter("PeekConsoleInputW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_PeekConsoleInputW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("PeekConsoleInputW(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PeekMessageA(LPMSG a0,
                                 HWND a1,
                                 UINT a2,
                                 UINT a3,
                                 UINT a4)
{
    _PrintEnter("PeekMessageA(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_PeekMessageA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("PeekMessageA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PeekMessageW(LPMSG a0,
                                 HWND a1,
                                 UINT a2,
                                 UINT a3,
                                 UINT a4)
{
    _PrintEnter("PeekMessageW(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_PeekMessageW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("PeekMessageW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PeekNamedPipe(HANDLE a0,
                                  LPVOID a1,
                                  DWORD a2,
                                  LPDWORD a3,
                                  LPDWORD a4,
                                  LPDWORD a5)
{
    _PrintEnter("PeekNamedPipe(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_PeekNamedPipe(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("PeekNamedPipe(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_Pie(HDC a0,
                        int a1,
                        int a2,
                        int a3,
                        int a4,
                        int a5,
                        int a6,
                        int a7,
                        int a8)
{
    _PrintEnter("Pie(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8);

    BOOL rv = 0;
    __try {
        rv = Real_Pie(a0, a1, a2, a3, a4, a5, a6, a7, a8);
    } __finally {
        _PrintExit("Pie(,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PlayEnhMetaFile(HDC a0,
                                    HENHMETAFILE a1,
                                    RECT* a2)
{
    _PrintEnter("PlayEnhMetaFile(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_PlayEnhMetaFile(a0, a1, a2);
    } __finally {
        _PrintExit("PlayEnhMetaFile(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PlayEnhMetaFileRecord(HDC a0,
                                          LPHANDLETABLE a1,
                                          ENHMETARECORD* a2,
                                          UINT a3)
{
    _PrintEnter("PlayEnhMetaFileRecord(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_PlayEnhMetaFileRecord(a0, a1, a2, a3);
    } __finally {
        _PrintExit("PlayEnhMetaFileRecord(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PlayMetaFile(HDC a0,
                                 HMETAFILE a1)
{
    _PrintEnter("PlayMetaFile(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_PlayMetaFile(a0, a1);
    } __finally {
        _PrintExit("PlayMetaFile(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PlayMetaFileRecord(HDC a0,
                                       LPHANDLETABLE a1,
                                       LPMETARECORD a2,
                                       UINT a3)
{
    _PrintEnter("PlayMetaFileRecord(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_PlayMetaFileRecord(a0, a1, a2, a3);
    } __finally {
        _PrintExit("PlayMetaFileRecord(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PlgBlt(HDC a0,
                           POINT* a1,
                           HDC a2,
                           int a3,
                           int a4,
                           int a5,
                           int a6,
                           HBITMAP a7,
                           int a8,
                           int a9)
{
    _PrintEnter("PlgBlt(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);

    BOOL rv = 0;
    __try {
        rv = Real_PlgBlt(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
    } __finally {
        _PrintExit("PlgBlt(,,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PolyBezier(HDC a0,
                               POINT* a1,
                               DWORD a2)
{
    _PrintEnter("PolyBezier(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_PolyBezier(a0, a1, a2);
    } __finally {
        _PrintExit("PolyBezier(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PolyBezierTo(HDC a0,
                                 POINT* a1,
                                 DWORD a2)
{
    _PrintEnter("PolyBezierTo(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_PolyBezierTo(a0, a1, a2);
    } __finally {
        _PrintExit("PolyBezierTo(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PolyDraw(HDC a0,
                             POINT* a1,
                             BYTE* a2,
                             int a3)
{
    _PrintEnter("PolyDraw(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_PolyDraw(a0, a1, a2, a3);
    } __finally {
        _PrintExit("PolyDraw(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PolyPolygon(HDC a0,
                                POINT* a1,
                                INT* a2,
                                int a3)
{
    _PrintEnter("PolyPolygon(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_PolyPolygon(a0, a1, a2, a3);
    } __finally {
        _PrintExit("PolyPolygon(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PolyPolyline(HDC a0,
                                 POINT* a1,
                                 DWORD* a2,
                                 DWORD a3)
{
    _PrintEnter("PolyPolyline(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_PolyPolyline(a0, a1, a2, a3);
    } __finally {
        _PrintExit("PolyPolyline(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PolyTextOutA(HDC a0,
                                 struct tagPOLYTEXTA* a1,
                                 int a2)
{
    _PrintEnter("PolyTextOutA(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_PolyTextOutA(a0, a1, a2);
    } __finally {
        _PrintExit("PolyTextOutA(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PolyTextOutW(HDC a0,
                                 struct tagPOLYTEXTW* a1,
                                 int a2)
{
    _PrintEnter("PolyTextOutW(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_PolyTextOutW(a0, a1, a2);
    } __finally {
        _PrintExit("PolyTextOutW(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_Polygon(HDC a0,
                            POINT* a1,
                            int a2)
{
    _PrintEnter("Polygon(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_Polygon(a0, a1, a2);
    } __finally {
        _PrintExit("Polygon(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_Polyline(HDC a0,
                             POINT* a1,
                             int a2)
{
    _PrintEnter("Polyline(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_Polyline(a0, a1, a2);
    } __finally {
        _PrintExit("Polyline(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PolylineTo(HDC a0,
                               POINT* a1,
                               DWORD a2)
{
    _PrintEnter("PolylineTo(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_PolylineTo(a0, a1, a2);
    } __finally {
        _PrintExit("PolylineTo(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PostMessageA(HWND a0,
                                 UINT a1,
                                 WPARAM a2,
                                 LPARAM a3)
{
    _PrintEnter("PostMessageA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_PostMessageA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("PostMessageA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PostMessageW(HWND a0,
                                 UINT a1,
                                 WPARAM a2,
                                 LPARAM a3)
{
    _PrintEnter("PostMessageW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_PostMessageW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("PostMessageW(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PostQueuedCompletionStatus(HANDLE a0,
                                               DWORD a1,
                                               ULONG_PTR a2,
                                               LPOVERLAPPED a3)
{
    _PrintEnter("PostQueuedCompletionStatus(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_PostQueuedCompletionStatus(a0, a1, a2, a3);
    } __finally {
        _PrintExit("PostQueuedCompletionStatus(,,,) -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_PostQuitMessage(int a0)
{
    _PrintEnter("PostQuitMessage(%lx)\n", a0);

    __try {
        Real_PostQuitMessage(a0);
    } __finally {
        _PrintExit("PostQuitMessage() ->\n");
    };
}

BOOL __stdcall Mine_PostThreadMessageA(DWORD a0,
                                       UINT a1,
                                       WPARAM a2,
                                       LPARAM a3)
{
    _PrintEnter("PostThreadMessageA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_PostThreadMessageA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("PostThreadMessageA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PostThreadMessageW(DWORD a0,
                                       UINT a1,
                                       WPARAM a2,
                                       LPARAM a3)
{
    _PrintEnter("PostThreadMessageW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_PostThreadMessageW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("PostThreadMessageW(,,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_PrepareTape(HANDLE a0,
                                 DWORD a1,
                                 BOOL a2)
{
    _PrintEnter("PrepareTape(%lx,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_PrepareTape(a0, a1, a2);
    } __finally {
        _PrintExit("PrepareTape(,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_ProgIDFromCLSID(IID& a0,
                                       LPOLESTR* a1)
{
    _PrintEnter("ProgIDFromCLSID(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_ProgIDFromCLSID(a0, a1);
    } __finally {
        _PrintExit("ProgIDFromCLSID(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_PropStgNameToFmtId(unsigned short* a0,
                                          FMTID* a1)
{
    _PrintEnter("PropStgNameToFmtId(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_PropStgNameToFmtId(a0, a1);
    } __finally {
        _PrintExit("PropStgNameToFmtId(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_PropVariantClear(PROPVARIANT* a0)
{
    _PrintEnter("PropVariantClear(%lx)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_PropVariantClear(a0);
    } __finally {
        _PrintExit("PropVariantClear() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_PropVariantCopy(PROPVARIANT* a0,
                                       PROPVARIANT* a1)
{
    _PrintEnter("PropVariantCopy(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_PropVariantCopy(a0, a1);
    } __finally {
        _PrintExit("PropVariantCopy(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PtInRect(RECT* a0,
                             POINT a1)
{
    _PrintEnter("PtInRect(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_PtInRect(a0, a1);
    } __finally {
        _PrintExit("PtInRect(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PtInRegion(HRGN a0,
                               int a1,
                               int a2)
{
    _PrintEnter("PtInRegion(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_PtInRegion(a0, a1, a2);
    } __finally {
        _PrintExit("PtInRegion(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PtVisible(HDC a0,
                              int a1,
                              int a2)
{
    _PrintEnter("PtVisible(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_PtVisible(a0, a1, a2);
    } __finally {
        _PrintExit("PtVisible(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PulseEvent(HANDLE a0)
{
    _PrintEnter("PulseEvent(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_PulseEvent(a0);
    } __finally {
        _PrintExit("PulseEvent() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_PurgeComm(HANDLE a0,
                              DWORD a1)
{
    _PrintEnter("PurgeComm(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_PurgeComm(a0, a1);
    } __finally {
        _PrintExit("PurgeComm(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_QueryDosDeviceA(LPCSTR a0,
                                     LPSTR a1,
                                     DWORD a2)
{
    _PrintEnter("QueryDosDeviceA(%hs,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_QueryDosDeviceA(a0, a1, a2);
    } __finally {
        _PrintExit("QueryDosDeviceA(,%hs,) -> %lx\n", a1, rv);
    };
    return rv;
}

DWORD __stdcall Mine_QueryDosDeviceW(LPCWSTR a0,
                                     LPWSTR a1,
                                     DWORD a2)
{
    _PrintEnter("QueryDosDeviceW(%ls,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_QueryDosDeviceW(a0, a1, a2);
    } __finally {
        _PrintExit("QueryDosDeviceW(,%ls,) -> %lx\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_QueryPerformanceCounter(LARGE_INTEGER* a0)
{
    _PrintEnter("QueryPerformanceCounter(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_QueryPerformanceCounter(a0);
    } __finally {
        _PrintExit("QueryPerformanceCounter() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_QueryPerformanceFrequency(LARGE_INTEGER* a0)
{
    _PrintEnter("QueryPerformanceFrequency(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_QueryPerformanceFrequency(a0);
    } __finally {
        _PrintExit("QueryPerformanceFrequency() -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_QueueUserAPC(PAPCFUNC a0,
                                  HANDLE a1,
                                  ULONG_PTR a2)
{
    _PrintEnter("QueueUserAPC(%lx,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_QueueUserAPC(a0, a1, a2);
    } __finally {
        _PrintExit("QueueUserAPC(,,) -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_RaiseException(DWORD a0,
                                   DWORD a1,
                                   DWORD a2,
                                   ULONG_PTR* a3)
{
    _PrintEnter("RaiseException(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    __try {
        Real_RaiseException(a0, a1, a2, a3);
    } __finally {
        _PrintExit("RaiseException(,,,) ->\n");
    };
}

HRESULT __stdcall Mine_ReadClassStg(struct IStorage* a0,
                                    CLSID* a1)
{
    _PrintEnter("ReadClassStg(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_ReadClassStg(a0, a1);
    } __finally {
        _PrintExit("ReadClassStg(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_ReadClassStm(LPSTREAM a0,
                                    CLSID* a1)
{
    _PrintEnter("ReadClassStm(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_ReadClassStm(a0, a1);
    } __finally {
        _PrintExit("ReadClassStm(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadConsoleA(HANDLE a0,
                                 LPVOID a1,
                                 DWORD a2,
                                 LPDWORD a3,
                                 LPVOID a4)
{
    _PrintEnter("ReadConsoleA(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ReadConsoleA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ReadConsoleA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadConsoleInputA(HANDLE a0,
                                      PINPUT_RECORD a1,
                                      DWORD a2,
                                      LPDWORD a3)
{
    _PrintEnter("ReadConsoleInputA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_ReadConsoleInputA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("ReadConsoleInputA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadConsoleInputW(HANDLE a0,
                                      PINPUT_RECORD a1,
                                      DWORD a2,
                                      LPDWORD a3)
{
    _PrintEnter("ReadConsoleInputW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_ReadConsoleInputW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("ReadConsoleInputW(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadConsoleOutputA(HANDLE a0,
                                       PCHAR_INFO a1,
                                       COORD a2,
                                       COORD a3,
                                       PSMALL_RECT a4)
{
    _PrintEnter("ReadConsoleOutputA(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ReadConsoleOutputA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ReadConsoleOutputA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadConsoleOutputAttribute(HANDLE a0,
                                               LPWORD a1,
                                               DWORD a2,
                                               COORD a3,
                                               LPDWORD a4)
{
    _PrintEnter("ReadConsoleOutputAttribute(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ReadConsoleOutputAttribute(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ReadConsoleOutputAttribute(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadConsoleOutputCharacterA(HANDLE a0,
                                                LPSTR a1,
                                                DWORD a2,
                                                COORD a3,
                                                LPDWORD a4)
{
    _PrintEnter("ReadConsoleOutputCharacterA(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ReadConsoleOutputCharacterA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ReadConsoleOutputCharacterA(,%hs,,,) -> %lx\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadConsoleOutputCharacterW(HANDLE a0,
                                                LPWSTR a1,
                                                DWORD a2,
                                                COORD a3,
                                                LPDWORD a4)
{
    _PrintEnter("ReadConsoleOutputCharacterW(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ReadConsoleOutputCharacterW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ReadConsoleOutputCharacterW(,%ls,,,) -> %lx\n", a1, rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadConsoleOutputW(HANDLE a0,
                                       PCHAR_INFO a1,
                                       COORD a2,
                                       COORD a3,
                                       PSMALL_RECT a4)
{
    _PrintEnter("ReadConsoleOutputW(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ReadConsoleOutputW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ReadConsoleOutputW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadConsoleW(HANDLE a0,
                                 LPVOID a1,
                                 DWORD a2,
                                 LPDWORD a3,
                                 LPVOID a4)
{
    _PrintEnter("ReadConsoleW(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ReadConsoleW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ReadConsoleW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadDirectoryChangesW(HANDLE a0,
                                          LPVOID a1,
                                          DWORD a2,
                                          BOOL a3,
                                          DWORD a4,
                                          LPDWORD a5,
                                          LPOVERLAPPED a6,
                                          LPOVERLAPPED_COMPLETION_ROUTINE a7)
{
    _PrintEnter("ReadDirectoryChangesW(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    BOOL rv = 0;
    __try {
        rv = Real_ReadDirectoryChangesW(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("ReadDirectoryChangesW(,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadFile(HANDLE a0,
                             LPVOID a1,
                             DWORD a2,
                             LPDWORD a3,
                             LPOVERLAPPED a4)
{
    _PrintEnter("ReadFile(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ReadFile(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ReadFile(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadFileEx(HANDLE a0,
                               LPVOID a1,
                               DWORD a2,
                               LPOVERLAPPED a3,
                               LPOVERLAPPED_COMPLETION_ROUTINE a4)
{
    _PrintEnter("ReadFileEx(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ReadFileEx(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ReadFileEx(,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_ReadFmtUserTypeStg(struct IStorage* a0,
                                          CLIPFORMAT* a1,
                                          LPOLESTR* a2)
{
    _PrintEnter("ReadFmtUserTypeStg(%lx,%lx,%lx)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_ReadFmtUserTypeStg(a0, a1, a2);
    } __finally {
        _PrintExit("ReadFmtUserTypeStg(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReadProcessMemory(HANDLE a0,
                                      LPCVOID a1,
                                      LPVOID a2,
                                      DWORD a3,
                                      LPDWORD a4)
{
    _PrintEnter("ReadProcessMemory(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ReadProcessMemory(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ReadProcessMemory(,,,,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_RealizePalette(HDC a0)
{
    _PrintEnter("RealizePalette(%lx)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_RealizePalette(a0);
    } __finally {
        _PrintExit("RealizePalette() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_RectInRegion(HRGN a0,
                                 RECT* a1)
{
    _PrintEnter("RectInRegion(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_RectInRegion(a0, a1);
    } __finally {
        _PrintExit("RectInRegion(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_RectVisible(HDC a0,
                                RECT* a1)
{
    _PrintEnter("RectVisible(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_RectVisible(a0, a1);
    } __finally {
        _PrintExit("RectVisible(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_Rectangle(HDC a0,
                              int a1,
                              int a2,
                              int a3,
                              int a4)
{
    _PrintEnter("Rectangle(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_Rectangle(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("Rectangle(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_RedrawWindow(HWND a0,
                                 RECT* a1,
                                 HRGN a2,
                                 UINT a3)
{
    _PrintEnter("RedrawWindow(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_RedrawWindow(a0, a1, a2, a3);
    } __finally {
        _PrintExit("RedrawWindow(,,,) -> %lx\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_RegisterClassA(WNDCLASSA* a0)
{
    _PrintEnter("RegisterClassA(%lx)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_RegisterClassA(a0);
    } __finally {
        _PrintExit("RegisterClassA() -> %lx\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_RegisterClassExA(struct tagWNDCLASSEXA* a0)
{
    _PrintEnter("RegisterClassExA(%lx)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_RegisterClassExA(a0);
    } __finally {
        _PrintExit("RegisterClassExA() -> %lx\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_RegisterClassExW(struct tagWNDCLASSEXW* a0)
{
    _PrintEnter("RegisterClassExW(%lx)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_RegisterClassExW(a0);
    } __finally {
        _PrintExit("RegisterClassExW() -> %lx\n", rv);
    };
    return rv;
}

ATOM __stdcall Mine_RegisterClassW(WNDCLASSW* a0)
{
    _PrintEnter("RegisterClassW(%lx)\n", a0);

    ATOM rv = 0;
    __try {
        rv = Real_RegisterClassW(a0);
    } __finally {
        _PrintExit("RegisterClassW() -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_RegisterClipboardFormatA(LPCSTR a0)
{
    _PrintEnter("RegisterClipboardFormatA(%hs)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_RegisterClipboardFormatA(a0);
    } __finally {
        _PrintExit("RegisterClipboardFormatA() -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_RegisterClipboardFormatW(LPCWSTR a0)
{
    _PrintEnter("RegisterClipboardFormatW(%ls)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_RegisterClipboardFormatW(a0);
    } __finally {
        _PrintExit("RegisterClipboardFormatW() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_RegisterDragDrop(HWND a0,
                                        struct IDropTarget* a1)
{
    _PrintEnter("RegisterDragDrop(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_RegisterDragDrop(a0, a1);
    } __finally {
        _PrintExit("RegisterDragDrop(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_RegisterHotKey(HWND a0,
                                   int a1,
                                   UINT a2,
                                   UINT a3)
{
    _PrintEnter("RegisterHotKey(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_RegisterHotKey(a0, a1, a2, a3);
    } __finally {
        _PrintExit("RegisterHotKey(,,,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_RegisterWindowMessageA(LPCSTR a0)
{
    _PrintEnter("RegisterWindowMessageA(%hs)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_RegisterWindowMessageA(a0);
    } __finally {
        _PrintExit("RegisterWindowMessageA() -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_RegisterWindowMessageW(LPCWSTR a0)
{
    _PrintEnter("RegisterWindowMessageW(%ls)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_RegisterWindowMessageW(a0);
    } __finally {
        _PrintExit("RegisterWindowMessageW() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReleaseCapture(void)
{
    _PrintEnter("ReleaseCapture()\n");

    BOOL rv = 0;
    __try {
        rv = Real_ReleaseCapture();
    } __finally {
        _PrintExit("ReleaseCapture() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_ReleaseDC(HWND a0,
                             HDC a1)
{
    _PrintEnter("ReleaseDC(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_ReleaseDC(a0, a1);
    } __finally {
        _PrintExit("ReleaseDC(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReleaseMutex(HANDLE a0)
{
    _PrintEnter("ReleaseMutex(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_ReleaseMutex(a0);
    } __finally {
        _PrintExit("ReleaseMutex() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReleaseSemaphore(HANDLE a0,
                                     LONG a1,
                                     LPLONG a2)
{
    _PrintEnter("ReleaseSemaphore(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_ReleaseSemaphore(a0, a1, a2);
    } __finally {
        _PrintExit("ReleaseSemaphore(,,) -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_ReleaseStgMedium(LPSTGMEDIUM a0)
{
    _PrintEnter("ReleaseStgMedium(%lx)\n", a0);

    __try {
        Real_ReleaseStgMedium(a0);
    } __finally {
        _PrintExit("ReleaseStgMedium() ->\n");
    };
}

BOOL __stdcall Mine_RemoveDirectoryA(LPCSTR a0)
{
    _PrintEnter("RemoveDirectoryA(%hs)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_RemoveDirectoryA(a0);
    } __finally {
        _PrintExit("RemoveDirectoryA() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_RemoveDirectoryW(LPCWSTR a0)
{
    _PrintEnter("RemoveDirectoryW(%ls)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_RemoveDirectoryW(a0);
    } __finally {
        _PrintExit("RemoveDirectoryW() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_RemoveFontResourceA(LPCSTR a0)
{
    _PrintEnter("RemoveFontResourceA(%hs)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_RemoveFontResourceA(a0);
    } __finally {
        _PrintExit("RemoveFontResourceA() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_RemoveFontResourceW(LPCWSTR a0)
{
    _PrintEnter("RemoveFontResourceW(%ls)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_RemoveFontResourceW(a0);
    } __finally {
        _PrintExit("RemoveFontResourceW() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_RemoveMenu(HMENU a0,
                               UINT a1,
                               UINT a2)
{
    _PrintEnter("RemoveMenu(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_RemoveMenu(a0, a1, a2);
    } __finally {
        _PrintExit("RemoveMenu(,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_RemovePropA(HWND a0,
                                  LPCSTR a1)
{
    _PrintEnter("RemovePropA(%lx,%hs)\n", a0, a1);

    HANDLE rv = 0;
    __try {
        rv = Real_RemovePropA(a0, a1);
    } __finally {
        _PrintExit("RemovePropA(,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_RemovePropW(HWND a0,
                                  LPCWSTR a1)
{
    _PrintEnter("RemovePropW(%lx,%ls)\n", a0, a1);

    HANDLE rv = 0;
    __try {
        rv = Real_RemovePropW(a0, a1);
    } __finally {
        _PrintExit("RemovePropW(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ReplyMessage(LRESULT a0)
{
    _PrintEnter("ReplyMessage(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_ReplyMessage(a0);
    } __finally {
        _PrintExit("ReplyMessage() -> %lx\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_ResetDCA(HDC a0,
                            struct _devicemodeA* a1)
{
    _PrintEnter("ResetDCA(%lx,%lx)\n", a0, a1);

    HDC rv = 0;
    __try {
        rv = Real_ResetDCA(a0, a1);
    } __finally {
        _PrintExit("ResetDCA(,) -> %lx\n", rv);
    };
    return rv;
}

HDC __stdcall Mine_ResetDCW(HDC a0,
                            struct _devicemodeW* a1)
{
    _PrintEnter("ResetDCW(%lx,%lx)\n", a0, a1);

    HDC rv = 0;
    __try {
        rv = Real_ResetDCW(a0, a1);
    } __finally {
        _PrintExit("ResetDCW(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ResetEvent(HANDLE a0)
{
    _PrintEnter("ResetEvent(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_ResetEvent(a0);
    } __finally {
        _PrintExit("ResetEvent() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ResizePalette(HPALETTE a0,
                                  UINT a1)
{
    _PrintEnter("ResizePalette(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_ResizePalette(a0, a1);
    } __finally {
        _PrintExit("ResizePalette(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_RestoreDC(HDC a0,
                              int a1)
{
    _PrintEnter("RestoreDC(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_RestoreDC(a0, a1);
    } __finally {
        _PrintExit("RestoreDC(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_ResumeThread(HANDLE a0)
{
    _PrintEnter("ResumeThread(%lx)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_ResumeThread(a0);
    } __finally {
        _PrintExit("ResumeThread() -> %lx\n", rv);
    };
    return rv;
}

LPARAM __stdcall Mine_ReuseDDElParam(LPARAM a0,
                                     UINT a1,
                                     UINT a2,
                                     UINT_PTR a3,
                                     UINT_PTR a4)
{
    _PrintEnter("ReuseDDElParam(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    LPARAM rv = 0;
    __try {
        rv = Real_ReuseDDElParam(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ReuseDDElParam(,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_RevokeDragDrop(HWND a0)
{
    _PrintEnter("RevokeDragDrop(%lx)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_RevokeDragDrop(a0);
    } __finally {
        _PrintExit("RevokeDragDrop() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_RoundRect(HDC a0,
                              int a1,
                              int a2,
                              int a3,
                              int a4,
                              int a5,
                              int a6)
{
    _PrintEnter("RoundRect(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_RoundRect(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("RoundRect(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_SaveDC(HDC a0)
{
    _PrintEnter("SaveDC(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_SaveDC(a0);
    } __finally {
        _PrintExit("SaveDC() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ScaleViewportExtEx(HDC a0,
                                       int a1,
                                       int a2,
                                       int a3,
                                       int a4,
                                       struct tagSIZE* a5)
{
    _PrintEnter("ScaleViewportExtEx(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_ScaleViewportExtEx(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("ScaleViewportExtEx(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ScaleWindowExtEx(HDC a0,
                                     int a1,
                                     int a2,
                                     int a3,
                                     int a4,
                                     struct tagSIZE* a5)
{
    _PrintEnter("ScaleWindowExtEx(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_ScaleWindowExtEx(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("ScaleWindowExtEx(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ScreenToClient(HWND a0,
                                   struct tagPOINT* a1)
{
    _PrintEnter("ScreenToClient(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_ScreenToClient(a0, a1);
    } __finally {
        _PrintExit("ScreenToClient(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ScrollConsoleScreenBufferA(HANDLE a0,
                                               SMALL_RECT* a1,
                                               SMALL_RECT* a2,
                                               COORD a3,
                                               CHAR_INFO* a4)
{
    _PrintEnter("ScrollConsoleScreenBufferA(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ScrollConsoleScreenBufferA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ScrollConsoleScreenBufferA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ScrollConsoleScreenBufferW(HANDLE a0,
                                               SMALL_RECT* a1,
                                               SMALL_RECT* a2,
                                               COORD a3,
                                               CHAR_INFO* a4)
{
    _PrintEnter("ScrollConsoleScreenBufferW(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ScrollConsoleScreenBufferW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ScrollConsoleScreenBufferW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ScrollDC(HDC a0,
                             int a1,
                             int a2,
                             RECT* a3,
                             RECT* a4,
                             HRGN a5,
                             LPRECT a6)
{
    _PrintEnter("ScrollDC(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_ScrollDC(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("ScrollDC(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ScrollWindow(HWND a0,
                                 int a1,
                                 int a2,
                                 RECT* a3,
                                 RECT* a4)
{
    _PrintEnter("ScrollWindow(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_ScrollWindow(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ScrollWindow(,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_ScrollWindowEx(HWND a0,
                                  int a1,
                                  int a2,
                                  RECT* a3,
                                  RECT* a4,
                                  HRGN a5,
                                  LPRECT a6,
                                  UINT a7)
{
    _PrintEnter("ScrollWindowEx(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    int rv = 0;
    __try {
        rv = Real_ScrollWindowEx(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("ScrollWindowEx(,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_SearchPathA(LPCSTR a0,
                                 LPCSTR a1,
                                 LPCSTR a2,
                                 DWORD a3,
                                 LPSTR a4,
                                 LPSTR* a5)
{
    _PrintEnter("SearchPathA(%hs,%hs,%hs,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    DWORD rv = 0;
    __try {
        rv = Real_SearchPathA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("SearchPathA(,,,,%hs,) -> %lx\n", a4, rv);
    };
    return rv;
}

DWORD __stdcall Mine_SearchPathW(LPCWSTR a0,
                                 LPCWSTR a1,
                                 LPCWSTR a2,
                                 DWORD a3,
                                 LPWSTR a4,
                                 LPWSTR* a5)
{
    _PrintEnter("SearchPathW(%ls,%ls,%ls,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    DWORD rv = 0;
    __try {
        rv = Real_SearchPathW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("SearchPathW(,,,,%ls,) -> %lx\n", a4, rv);
    };
    return rv;
}

BOOL __stdcall Mine_SelectClipPath(HDC a0,
                                   int a1)
{
    _PrintEnter("SelectClipPath(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SelectClipPath(a0, a1);
    } __finally {
        _PrintExit("SelectClipPath(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_SelectClipRgn(HDC a0,
                                 HRGN a1)
{
    _PrintEnter("SelectClipRgn(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_SelectClipRgn(a0, a1);
    } __finally {
        _PrintExit("SelectClipRgn(,) -> %lx\n", rv);
    };
    return rv;
}

HGDIOBJ __stdcall Mine_SelectObject(HDC a0,
                                    HGDIOBJ a1)
{
    _PrintEnter("SelectObject(%lx,%lx)\n", a0, a1);

    HGDIOBJ rv = 0;
    __try {
        rv = Real_SelectObject(a0, a1);
    } __finally {
        _PrintExit("SelectObject(,) -> %lx\n", rv);
    };
    return rv;
}

HPALETTE __stdcall Mine_SelectPalette(HDC a0,
                                      HPALETTE a1,
                                      BOOL a2)
{
    _PrintEnter("SelectPalette(%lx,%lx,%lx)\n", a0, a1, a2);

    HPALETTE rv = 0;
    __try {
        rv = Real_SelectPalette(a0, a1, a2);
    } __finally {
        _PrintExit("SelectPalette(,,) -> %lx\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_SendDlgItemMessageA(HWND a0,
                                           int a1,
                                           UINT a2,
                                           WPARAM a3,
                                           LPARAM a4)
{
    _PrintEnter("SendDlgItemMessageA(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    LRESULT rv = 0;
    __try {
        rv = Real_SendDlgItemMessageA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("SendDlgItemMessageA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_SendDlgItemMessageW(HWND a0,
                                           int a1,
                                           UINT a2,
                                           WPARAM a3,
                                           LPARAM a4)
{
    _PrintEnter("SendDlgItemMessageW(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    LRESULT rv = 0;
    __try {
        rv = Real_SendDlgItemMessageW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("SendDlgItemMessageW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_SendMessageA(HWND a0,
                                    UINT a1,
                                    WPARAM a2,
                                    LPARAM a3)
{
    _PrintEnter("SendMessageA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    LRESULT rv = 0;
    __try {
        rv = Real_SendMessageA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SendMessageA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SendMessageCallbackA(HWND a0,
                                         UINT a1,
                                         WPARAM a2,
                                         LPARAM a3,
                                         SENDASYNCPROC a4,
                                         ULONG_PTR a5)
{
    _PrintEnter("SendMessageCallbackA(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_SendMessageCallbackA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("SendMessageCallbackA(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SendMessageCallbackW(HWND a0,
                                         UINT a1,
                                         WPARAM a2,
                                         LPARAM a3,
                                         SENDASYNCPROC a4,
                                         ULONG_PTR a5)
{
    _PrintEnter("SendMessageCallbackW(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_SendMessageCallbackW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("SendMessageCallbackW(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_SendMessageTimeoutA(HWND a0,
                                           UINT a1,
                                           WPARAM a2,
                                           LPARAM a3,
                                           UINT a4,
                                           UINT a5,
                                           PULONG_PTR a6)
{
    _PrintEnter("SendMessageTimeoutA(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    LRESULT rv = 0;
    __try {
        rv = Real_SendMessageTimeoutA(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("SendMessageTimeoutA(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_SendMessageTimeoutW(HWND a0,
                                           UINT a1,
                                           WPARAM a2,
                                           LPARAM a3,
                                           UINT a4,
                                           UINT a5,
                                           PULONG_PTR a6)
{
    _PrintEnter("SendMessageTimeoutW(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    LRESULT rv = 0;
    __try {
        rv = Real_SendMessageTimeoutW(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("SendMessageTimeoutW(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

LRESULT __stdcall Mine_SendMessageW(HWND a0,
                                    UINT a1,
                                    WPARAM a2,
                                    LPARAM a3)
{
    _PrintEnter("SendMessageW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    LRESULT rv = 0;
    __try {
        rv = Real_SendMessageW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SendMessageW(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SendNotifyMessageA(HWND a0,
                                       UINT a1,
                                       WPARAM a2,
                                       LPARAM a3)
{
    _PrintEnter("SendNotifyMessageA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SendNotifyMessageA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SendNotifyMessageA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SendNotifyMessageW(HWND a0,
                                       UINT a1,
                                       WPARAM a2,
                                       LPARAM a3)
{
    _PrintEnter("SendNotifyMessageW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SendNotifyMessageW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SendNotifyMessageW(,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetAbortProc(HDC a0,
                                ABORTPROC a1)
{
    _PrintEnter("SetAbortProc(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_SetAbortProc(a0, a1);
    } __finally {
        _PrintExit("SetAbortProc(,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_SetActiveWindow(HWND a0)
{
    _PrintEnter("SetActiveWindow(%lx)\n", a0);

    HWND rv = 0;
    __try {
        rv = Real_SetActiveWindow(a0);
    } __finally {
        _PrintExit("SetActiveWindow() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetArcDirection(HDC a0,
                                   int a1)
{
    _PrintEnter("SetArcDirection(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_SetArcDirection(a0, a1);
    } __finally {
        _PrintExit("SetArcDirection(,) -> %lx\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_SetBitmapBits(HBITMAP a0,
                                  DWORD a1,
                                  void* a2)
{
    _PrintEnter("SetBitmapBits(%lx,%lx,%lx)\n", a0, a1, a2);

    LONG rv = 0;
    __try {
        rv = Real_SetBitmapBits(a0, a1, a2);
    } __finally {
        _PrintExit("SetBitmapBits(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetBitmapDimensionEx(HBITMAP a0,
                                         int a1,
                                         int a2,
                                         struct tagSIZE* a3)
{
    _PrintEnter("SetBitmapDimensionEx(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetBitmapDimensionEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetBitmapDimensionEx(,,,) -> %lx\n", rv);
    };
    return rv;
}

COLORREF __stdcall Mine_SetBkColor(HDC a0,
                                   COLORREF a1)
{
    _PrintEnter("SetBkColor(%lx,%lx)\n", a0, a1);

    COLORREF rv = 0;
    __try {
        rv = Real_SetBkColor(a0, a1);
    } __finally {
        _PrintExit("SetBkColor(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetBkMode(HDC a0,
                             int a1)
{
    _PrintEnter("SetBkMode(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_SetBkMode(a0, a1);
    } __finally {
        _PrintExit("SetBkMode(,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_SetBoundsRect(HDC a0,
                                  RECT* a1,
                                  UINT a2)
{
    _PrintEnter("SetBoundsRect(%lx,%lx,%lx)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real_SetBoundsRect(a0, a1, a2);
    } __finally {
        _PrintExit("SetBoundsRect(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetBrushOrgEx(HDC a0,
                                  int a1,
                                  int a2,
                                  struct tagPOINT* a3)
{
    _PrintEnter("SetBrushOrgEx(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetBrushOrgEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetBrushOrgEx(,,,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_SetCapture(HWND a0)
{
    _PrintEnter("SetCapture(%lx)\n", a0);

    HWND rv = 0;
    __try {
        rv = Real_SetCapture(a0);
    } __finally {
        _PrintExit("SetCapture() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetCaretBlinkTime(UINT a0)
{
    _PrintEnter("SetCaretBlinkTime(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetCaretBlinkTime(a0);
    } __finally {
        _PrintExit("SetCaretBlinkTime() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetCaretPos(int a0,
                                int a1)
{
    _PrintEnter("SetCaretPos(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetCaretPos(a0, a1);
    } __finally {
        _PrintExit("SetCaretPos(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_SetClassLongA(HWND a0,
                                   int a1,
                                   LONG a2)
{
    _PrintEnter("SetClassLongA(%lx,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_SetClassLongA(a0, a1, a2);
    } __finally {
        _PrintExit("SetClassLongA(,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_SetClassLongW(HWND a0,
                                   int a1,
                                   LONG a2)
{
    _PrintEnter("SetClassLongW(%lx,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_SetClassLongW(a0, a1, a2);
    } __finally {
        _PrintExit("SetClassLongW(,,) -> %lx\n", rv);
    };
    return rv;
}

WORD __stdcall Mine_SetClassWord(HWND a0,
                                 int a1,
                                 WORD a2)
{
    _PrintEnter("SetClassWord(%lx,%lx,%lx)\n", a0, a1, a2);

    WORD rv = 0;
    __try {
        rv = Real_SetClassWord(a0, a1, a2);
    } __finally {
        _PrintExit("SetClassWord(,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_SetClipboardData(UINT a0,
                                       HANDLE a1)
{
    _PrintEnter("SetClipboardData(%lx,%lx)\n", a0, a1);

    HANDLE rv = 0;
    __try {
        rv = Real_SetClipboardData(a0, a1);
    } __finally {
        _PrintExit("SetClipboardData(,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_SetClipboardViewer(HWND a0)
{
    _PrintEnter("SetClipboardViewer(%lx)\n", a0);

    HWND rv = 0;
    __try {
        rv = Real_SetClipboardViewer(a0);
    } __finally {
        _PrintExit("SetClipboardViewer() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetColorAdjustment(HDC a0,
                                       COLORADJUSTMENT* a1)
{
    _PrintEnter("SetColorAdjustment(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetColorAdjustment(a0, a1);
    } __finally {
        _PrintExit("SetColorAdjustment(,) -> %lx\n", rv);
    };
    return rv;
}

HCOLORSPACE __stdcall Mine_SetColorSpace(HDC a0,
                                         HCOLORSPACE a1)
{
    _PrintEnter("SetColorSpace(%lx,%lx)\n", a0, a1);

    HCOLORSPACE rv = 0;
    __try {
        rv = Real_SetColorSpace(a0, a1);
    } __finally {
        _PrintExit("SetColorSpace(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetCommBreak(HANDLE a0)
{
    _PrintEnter("SetCommBreak(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetCommBreak(a0);
    } __finally {
        _PrintExit("SetCommBreak() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetCommConfig(HANDLE a0,
                                  LPCOMMCONFIG a1,
                                  DWORD a2)
{
    _PrintEnter("SetCommConfig(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetCommConfig(a0, a1, a2);
    } __finally {
        _PrintExit("SetCommConfig(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetCommMask(HANDLE a0,
                                DWORD a1)
{
    _PrintEnter("SetCommMask(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetCommMask(a0, a1);
    } __finally {
        _PrintExit("SetCommMask(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetCommState(HANDLE a0,
                                 struct _DCB* a1)
{
    _PrintEnter("SetCommState(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetCommState(a0, a1);
    } __finally {
        _PrintExit("SetCommState(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetCommTimeouts(HANDLE a0,
                                    struct _COMMTIMEOUTS* a1)
{
    _PrintEnter("SetCommTimeouts(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetCommTimeouts(a0, a1);
    } __finally {
        _PrintExit("SetCommTimeouts(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetComputerNameA(LPCSTR a0)
{
    _PrintEnter("SetComputerNameA(%hs)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetComputerNameA(a0);
    } __finally {
        _PrintExit("SetComputerNameA() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetComputerNameW(LPCWSTR a0)
{
    _PrintEnter("SetComputerNameW(%ls)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetComputerNameW(a0);
    } __finally {
        _PrintExit("SetComputerNameW() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetConsoleActiveScreenBuffer(HANDLE a0)
{
    _PrintEnter("SetConsoleActiveScreenBuffer(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetConsoleActiveScreenBuffer(a0);
    } __finally {
        _PrintExit("SetConsoleActiveScreenBuffer() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetConsoleCP(UINT a0)
{
    _PrintEnter("SetConsoleCP(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetConsoleCP(a0);
    } __finally {
        _PrintExit("SetConsoleCP() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetConsoleCtrlHandler(PHANDLER_ROUTINE a0,
                                          BOOL a1)
{
    _PrintEnter("SetConsoleCtrlHandler(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetConsoleCtrlHandler(a0, a1);
    } __finally {
        _PrintExit("SetConsoleCtrlHandler(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetConsoleCursorInfo(HANDLE a0,
                                         CONSOLE_CURSOR_INFO* a1)
{
    _PrintEnter("SetConsoleCursorInfo(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetConsoleCursorInfo(a0, a1);
    } __finally {
        _PrintExit("SetConsoleCursorInfo(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetConsoleCursorPosition(HANDLE a0,
                                             COORD a1)
{
    _PrintEnter("SetConsoleCursorPosition(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetConsoleCursorPosition(a0, a1);
    } __finally {
        _PrintExit("SetConsoleCursorPosition(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetConsoleMode(HANDLE a0,
                                   DWORD a1)
{
    _PrintEnter("SetConsoleMode(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetConsoleMode(a0, a1);
    } __finally {
        _PrintExit("SetConsoleMode(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetConsoleOutputCP(UINT a0)
{
    _PrintEnter("SetConsoleOutputCP(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetConsoleOutputCP(a0);
    } __finally {
        _PrintExit("SetConsoleOutputCP() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetConsoleScreenBufferSize(HANDLE a0,
                                               COORD a1)
{
    _PrintEnter("SetConsoleScreenBufferSize(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetConsoleScreenBufferSize(a0, a1);
    } __finally {
        _PrintExit("SetConsoleScreenBufferSize(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetConsoleTextAttribute(HANDLE a0,
                                            WORD a1)
{
    _PrintEnter("SetConsoleTextAttribute(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetConsoleTextAttribute(a0, a1);
    } __finally {
        _PrintExit("SetConsoleTextAttribute(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetConsoleTitleA(LPCSTR a0)
{
    _PrintEnter("SetConsoleTitleA(%hs)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetConsoleTitleA(a0);
    } __finally {
        _PrintExit("SetConsoleTitleA() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetConsoleTitleW(LPCWSTR a0)
{
    _PrintEnter("SetConsoleTitleW(%ls)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetConsoleTitleW(a0);
    } __finally {
        _PrintExit("SetConsoleTitleW() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetConsoleWindowInfo(HANDLE a0,
                                         BOOL a1,
                                         SMALL_RECT* a2)
{
    _PrintEnter("SetConsoleWindowInfo(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetConsoleWindowInfo(a0, a1, a2);
    } __finally {
        _PrintExit("SetConsoleWindowInfo(,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_SetConvertStg(struct IStorage* a0,
                                     BOOL a1)
{
    _PrintEnter("SetConvertStg(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_SetConvertStg(a0, a1);
    } __finally {
        _PrintExit("SetConvertStg(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetCurrentDirectoryA(LPCSTR a0)
{
    _PrintEnter("SetCurrentDirectoryA(%hs)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetCurrentDirectoryA(a0);
    } __finally {
        _PrintExit("SetCurrentDirectoryA() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetCurrentDirectoryW(LPCWSTR a0)
{
    _PrintEnter("SetCurrentDirectoryW(%ls)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetCurrentDirectoryW(a0);
    } __finally {
        _PrintExit("SetCurrentDirectoryW() -> %lx\n", rv);
    };
    return rv;
}

HCURSOR __stdcall Mine_SetCursor(HCURSOR a0)
{
    _PrintEnter("SetCursor(%lx)\n", a0);

    HCURSOR rv = 0;
    __try {
        rv = Real_SetCursor(a0);
    } __finally {
        _PrintExit("SetCursor() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetCursorPos(int a0,
                                 int a1)
{
    _PrintEnter("SetCursorPos(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetCursorPos(a0, a1);
    } __finally {
        _PrintExit("SetCursorPos(,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_SetDIBColorTable(HDC a0,
                                     UINT a1,
                                     UINT a2,
                                     RGBQUAD* a3)
{
    _PrintEnter("SetDIBColorTable(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    UINT rv = 0;
    __try {
        rv = Real_SetDIBColorTable(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetDIBColorTable(,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetDIBits(HDC a0,
                             HBITMAP a1,
                             UINT a2,
                             UINT a3,
                             void* a4,
                             struct tagBITMAPINFO* a5,
                             UINT a6)
{
    _PrintEnter("SetDIBits(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    int rv = 0;
    __try {
        rv = Real_SetDIBits(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("SetDIBits(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetDIBitsToDevice(HDC a0,
                                     int a1,
                                     int a2,
                                     DWORD a3,
                                     DWORD a4,
                                     int a5,
                                     int a6,
                                     UINT a7,
                                     UINT a8,
                                     void* a9,
                                     struct tagBITMAPINFO* a10,
                                     UINT a11)
{
    _PrintEnter("SetDIBitsToDevice(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);

    int rv = 0;
    __try {
        rv = Real_SetDIBitsToDevice(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
    } __finally {
        _PrintExit("SetDIBitsToDevice(,,,,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_SetDebugErrorLevel(DWORD a0)
{
    _PrintEnter("SetDebugErrorLevel(%lx)\n", a0);

    __try {
        Real_SetDebugErrorLevel(a0);
    } __finally {
        _PrintExit("SetDebugErrorLevel() ->\n");
    };
}

BOOL __stdcall Mine_SetDefaultCommConfigA(LPCSTR a0,
                                          LPCOMMCONFIG a1,
                                          DWORD a2)
{
    _PrintEnter("SetDefaultCommConfigA(%hs,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetDefaultCommConfigA(a0, a1, a2);
    } __finally {
        _PrintExit("SetDefaultCommConfigA(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetDefaultCommConfigW(LPCWSTR a0,
                                          LPCOMMCONFIG a1,
                                          DWORD a2)
{
    _PrintEnter("SetDefaultCommConfigW(%ls,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetDefaultCommConfigW(a0, a1, a2);
    } __finally {
        _PrintExit("SetDefaultCommConfigW(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetDeviceGammaRamp(HDC a0,
                                       LPVOID a1)
{
    _PrintEnter("SetDeviceGammaRamp(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetDeviceGammaRamp(a0, a1);
    } __finally {
        _PrintExit("SetDeviceGammaRamp(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetDlgItemInt(HWND a0,
                                  int a1,
                                  UINT a2,
                                  BOOL a3)
{
    _PrintEnter("SetDlgItemInt(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetDlgItemInt(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetDlgItemInt(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetDlgItemTextA(HWND a0,
                                    int a1,
                                    LPCSTR a2)
{
    _PrintEnter("SetDlgItemTextA(%lx,%lx,%hs)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetDlgItemTextA(a0, a1, a2);
    } __finally {
        _PrintExit("SetDlgItemTextA(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetDlgItemTextW(HWND a0,
                                    int a1,
                                    LPCWSTR a2)
{
    _PrintEnter("SetDlgItemTextW(%lx,%lx,%ls)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetDlgItemTextW(a0, a1, a2);
    } __finally {
        _PrintExit("SetDlgItemTextW(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetDoubleClickTime(UINT a0)
{
    _PrintEnter("SetDoubleClickTime(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetDoubleClickTime(a0);
    } __finally {
        _PrintExit("SetDoubleClickTime() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetEndOfFile(HANDLE a0)
{
    _PrintEnter("SetEndOfFile(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetEndOfFile(a0);
    } __finally {
        _PrintExit("SetEndOfFile() -> %lx\n", rv);
    };
    return rv;
}

HENHMETAFILE __stdcall Mine_SetEnhMetaFileBits(UINT a0,
                                               BYTE* a1)
{
    _PrintEnter("SetEnhMetaFileBits(%lx,%lx)\n", a0, a1);

    HENHMETAFILE rv = 0;
    __try {
        rv = Real_SetEnhMetaFileBits(a0, a1);
    } __finally {
        _PrintExit("SetEnhMetaFileBits(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetEnvironmentVariableA(LPCSTR a0,
                                            LPCSTR a1)
{
    _PrintEnter("SetEnvironmentVariableA(%hs,%hs)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetEnvironmentVariableA(a0, a1);
    } __finally {
        _PrintExit("SetEnvironmentVariableA(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetEnvironmentVariableW(LPCWSTR a0,
                                            LPCWSTR a1)
{
    _PrintEnter("SetEnvironmentVariableW(%ls,%ls)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetEnvironmentVariableW(a0, a1);
    } __finally {
        _PrintExit("SetEnvironmentVariableW(,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_SetErrorMode(UINT a0)
{
    _PrintEnter("SetErrorMode(%lx)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_SetErrorMode(a0);
    } __finally {
        _PrintExit("SetErrorMode() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetEvent(HANDLE a0)
{
    _PrintEnter("SetEvent(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetEvent(a0);
    } __finally {
        _PrintExit("SetEvent() -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_SetFileApisToANSI(void)
{
    _PrintEnter("SetFileApisToANSI()\n");

    __try {
        Real_SetFileApisToANSI();
    } __finally {
        _PrintExit("SetFileApisToANSI() ->\n");
    };
}

void __stdcall Mine_SetFileApisToOEM(void)
{
    _PrintEnter("SetFileApisToOEM()\n");

    __try {
        Real_SetFileApisToOEM();
    } __finally {
        _PrintExit("SetFileApisToOEM() ->\n");
    };
}

BOOL __stdcall Mine_SetFileAttributesA(LPCSTR a0,
                                       DWORD a1)
{
    _PrintEnter("SetFileAttributesA(%hs,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetFileAttributesA(a0, a1);
    } __finally {
        _PrintExit("SetFileAttributesA(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetFileAttributesW(LPCWSTR a0,
                                       DWORD a1)
{
    _PrintEnter("SetFileAttributesW(%ls,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetFileAttributesW(a0, a1);
    } __finally {
        _PrintExit("SetFileAttributesW(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_SetFilePointer(HANDLE a0,
                                    LONG a1,
                                    PLONG a2,
                                    DWORD a3)
{
    _PrintEnter("SetFilePointer(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    DWORD rv = 0;
    __try {
        rv = Real_SetFilePointer(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetFilePointer(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetFileTime(HANDLE a0,
                                FILETIME* a1,
                                FILETIME* a2,
                                FILETIME* a3)
{
    _PrintEnter("SetFileTime(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetFileTime(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetFileTime(,,,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_SetFocus(HWND a0)
{
    _PrintEnter("SetFocus(%lx)\n", a0);

    HWND rv = 0;
    __try {
        rv = Real_SetFocus(a0);
    } __finally {
        _PrintExit("SetFocus() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetForegroundWindow(HWND a0)
{
    _PrintEnter("SetForegroundWindow(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetForegroundWindow(a0);
    } __finally {
        _PrintExit("SetForegroundWindow() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetGraphicsMode(HDC a0,
                                   int a1)
{
    _PrintEnter("SetGraphicsMode(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_SetGraphicsMode(a0, a1);
    } __finally {
        _PrintExit("SetGraphicsMode(,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_SetHandleCount(UINT a0)
{
    _PrintEnter("SetHandleCount(%lx)\n", a0);

    UINT rv = 0;
    __try {
        rv = Real_SetHandleCount(a0);
    } __finally {
        _PrintExit("SetHandleCount() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetHandleInformation(HANDLE a0,
                                         DWORD a1,
                                         DWORD a2)
{
    _PrintEnter("SetHandleInformation(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetHandleInformation(a0, a1, a2);
    } __finally {
        _PrintExit("SetHandleInformation(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetICMMode(HDC a0,
                              int a1)
{
    _PrintEnter("SetICMMode(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_SetICMMode(a0, a1);
    } __finally {
        _PrintExit("SetICMMode(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetICMProfileA(HDC a0,
                                   LPSTR a1)
{
    _PrintEnter("SetICMProfileA(%lx,%hs)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetICMProfileA(a0, a1);
    } __finally {
        _PrintExit("SetICMProfileA(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetICMProfileW(HDC a0,
                                   LPWSTR a1)
{
    _PrintEnter("SetICMProfileW(%lx,%ls)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetICMProfileW(a0, a1);
    } __finally {
        _PrintExit("SetICMProfileW(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetKeyboardState(LPBYTE a0)
{
    _PrintEnter("SetKeyboardState(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetKeyboardState(a0);
    } __finally {
        _PrintExit("SetKeyboardState() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetLocalTime(SYSTEMTIME* a0)
{
    _PrintEnter("SetLocalTime(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetLocalTime(a0);
    } __finally {
        _PrintExit("SetLocalTime() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetLocaleInfoA(LCID a0,
                                   LCTYPE a1,
                                   LPCSTR a2)
{
    _PrintEnter("SetLocaleInfoA(%lx,%lx,%hs)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetLocaleInfoA(a0, a1, a2);
    } __finally {
        _PrintExit("SetLocaleInfoA(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetLocaleInfoW(LCID a0,
                                   LCTYPE a1,
                                   LPCWSTR a2)
{
    _PrintEnter("SetLocaleInfoW(%lx,%lx,%ls)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetLocaleInfoW(a0, a1, a2);
    } __finally {
        _PrintExit("SetLocaleInfoW(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetMailslotInfo(HANDLE a0,
                                    DWORD a1)
{
    _PrintEnter("SetMailslotInfo(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetMailslotInfo(a0, a1);
    } __finally {
        _PrintExit("SetMailslotInfo(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetMapMode(HDC a0,
                              int a1)
{
    _PrintEnter("SetMapMode(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_SetMapMode(a0, a1);
    } __finally {
        _PrintExit("SetMapMode(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_SetMapperFlags(HDC a0,
                                    DWORD a1)
{
    _PrintEnter("SetMapperFlags(%lx,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_SetMapperFlags(a0, a1);
    } __finally {
        _PrintExit("SetMapperFlags(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetMenu(HWND a0,
                            HMENU a1)
{
    _PrintEnter("SetMenu(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetMenu(a0, a1);
    } __finally {
        _PrintExit("SetMenu(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetMenuContextHelpId(HMENU a0,
                                         DWORD a1)
{
    _PrintEnter("SetMenuContextHelpId(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetMenuContextHelpId(a0, a1);
    } __finally {
        _PrintExit("SetMenuContextHelpId(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetMenuDefaultItem(HMENU a0,
                                       UINT a1,
                                       UINT a2)
{
    _PrintEnter("SetMenuDefaultItem(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetMenuDefaultItem(a0, a1, a2);
    } __finally {
        _PrintExit("SetMenuDefaultItem(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetMenuItemBitmaps(HMENU a0,
                                       UINT a1,
                                       UINT a2,
                                       HBITMAP a3,
                                       HBITMAP a4)
{
    _PrintEnter("SetMenuItemBitmaps(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_SetMenuItemBitmaps(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("SetMenuItemBitmaps(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetMenuItemInfoA(HMENU a0,
                                     UINT a1,
                                     BOOL a2,
                                     struct tagMENUITEMINFOA* a3)
{
    _PrintEnter("SetMenuItemInfoA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetMenuItemInfoA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetMenuItemInfoA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetMenuItemInfoW(HMENU a0,
                                     UINT a1,
                                     BOOL a2,
                                     struct tagMENUITEMINFOW* a3)
{
    _PrintEnter("SetMenuItemInfoW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetMenuItemInfoW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetMenuItemInfoW(,,,) -> %lx\n", rv);
    };
    return rv;
}

LPARAM __stdcall Mine_SetMessageExtraInfo(LPARAM a0)
{
    _PrintEnter("SetMessageExtraInfo(%lx)\n", a0);

    LPARAM rv = 0;
    __try {
        rv = Real_SetMessageExtraInfo(a0);
    } __finally {
        _PrintExit("SetMessageExtraInfo() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetMessageQueue(int a0)
{
    _PrintEnter("SetMessageQueue(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetMessageQueue(a0);
    } __finally {
        _PrintExit("SetMessageQueue() -> %lx\n", rv);
    };
    return rv;
}

HMETAFILE __stdcall Mine_SetMetaFileBitsEx(UINT a0,
                                           BYTE* a1)
{
    _PrintEnter("SetMetaFileBitsEx(%lx,%lx)\n", a0, a1);

    HMETAFILE rv = 0;
    __try {
        rv = Real_SetMetaFileBitsEx(a0, a1);
    } __finally {
        _PrintExit("SetMetaFileBitsEx(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetMetaRgn(HDC a0)
{
    _PrintEnter("SetMetaRgn(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_SetMetaRgn(a0);
    } __finally {
        _PrintExit("SetMetaRgn() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetMiterLimit(HDC a0,
                                  FLOAT a1,
                                  PFLOAT a2)
{
    _PrintEnter("SetMiterLimit(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetMiterLimit(a0, a1, a2);
    } __finally {
        _PrintExit("SetMiterLimit(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetNamedPipeHandleState(HANDLE a0,
                                            LPDWORD a1,
                                            LPDWORD a2,
                                            LPDWORD a3)
{
    _PrintEnter("SetNamedPipeHandleState(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetNamedPipeHandleState(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetNamedPipeHandleState(,,,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_SetPaletteEntries(HPALETTE a0,
                                      UINT a1,
                                      UINT a2,
                                      PALETTEENTRY* a3)
{
    _PrintEnter("SetPaletteEntries(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    UINT rv = 0;
    __try {
        rv = Real_SetPaletteEntries(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetPaletteEntries(,,,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_SetParent(HWND a0,
                              HWND a1)
{
    _PrintEnter("SetParent(%lx,%lx)\n", a0, a1);

    HWND rv = 0;
    __try {
        rv = Real_SetParent(a0, a1);
    } __finally {
        _PrintExit("SetParent(,) -> %lx\n", rv);
    };
    return rv;
}

COLORREF __stdcall Mine_SetPixel(HDC a0,
                                 int a1,
                                 int a2,
                                 COLORREF a3)
{
    _PrintEnter("SetPixel(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    COLORREF rv = 0;
    __try {
        rv = Real_SetPixel(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetPixel(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetPixelFormat(HDC a0,
                                   int a1,
                                   PIXELFORMATDESCRIPTOR* a2)
{
    _PrintEnter("SetPixelFormat(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetPixelFormat(a0, a1, a2);
    } __finally {
        _PrintExit("SetPixelFormat(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetPixelV(HDC a0,
                              int a1,
                              int a2,
                              COLORREF a3)
{
    _PrintEnter("SetPixelV(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetPixelV(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetPixelV(,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetPolyFillMode(HDC a0,
                                   int a1)
{
    _PrintEnter("SetPolyFillMode(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_SetPolyFillMode(a0, a1);
    } __finally {
        _PrintExit("SetPolyFillMode(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetPriorityClass(HANDLE a0,
                                     DWORD a1)
{
    _PrintEnter("SetPriorityClass(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetPriorityClass(a0, a1);
    } __finally {
        _PrintExit("SetPriorityClass(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetProcessAffinityMask(HANDLE a0,
                                           DWORD a1)
{
    _PrintEnter("SetProcessAffinityMask(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetProcessAffinityMask(a0, a1);
    } __finally {
        _PrintExit("SetProcessAffinityMask(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetProcessPriorityBoost(HANDLE a0,
                                            BOOL a1)
{
    _PrintEnter("SetProcessPriorityBoost(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetProcessPriorityBoost(a0, a1);
    } __finally {
        _PrintExit("SetProcessPriorityBoost(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetProcessShutdownParameters(DWORD a0,
                                                 DWORD a1)
{
    _PrintEnter("SetProcessShutdownParameters(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetProcessShutdownParameters(a0, a1);
    } __finally {
        _PrintExit("SetProcessShutdownParameters(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetProcessWindowStation(HWINSTA a0)
{
    _PrintEnter("SetProcessWindowStation(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetProcessWindowStation(a0);
    } __finally {
        _PrintExit("SetProcessWindowStation() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetProcessWorkingSetSize(HANDLE a0,
                                             SIZE_T a1,
                                             SIZE_T a2)
{
    _PrintEnter("SetProcessWorkingSetSize(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetProcessWorkingSetSize(a0, a1, a2);
    } __finally {
        _PrintExit("SetProcessWorkingSetSize(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetPropA(HWND a0,
                             LPCSTR a1,
                             HANDLE a2)
{
    _PrintEnter("SetPropA(%lx,%hs,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetPropA(a0, a1, a2);
    } __finally {
        _PrintExit("SetPropA(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetPropW(HWND a0,
                             LPCWSTR a1,
                             HANDLE a2)
{
    _PrintEnter("SetPropW(%lx,%ls,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetPropW(a0, a1, a2);
    } __finally {
        _PrintExit("SetPropW(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetROP2(HDC a0,
                           int a1)
{
    _PrintEnter("SetROP2(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_SetROP2(a0, a1);
    } __finally {
        _PrintExit("SetROP2(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetRect(LPRECT a0,
                            int a1,
                            int a2,
                            int a3,
                            int a4)
{
    _PrintEnter("SetRect(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_SetRect(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("SetRect(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetRectEmpty(LPRECT a0)
{
    _PrintEnter("SetRectEmpty(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetRectEmpty(a0);
    } __finally {
        _PrintExit("SetRectEmpty() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetRectRgn(HRGN a0,
                               int a1,
                               int a2,
                               int a3,
                               int a4)
{
    _PrintEnter("SetRectRgn(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_SetRectRgn(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("SetRectRgn(,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetScrollInfo(HWND a0,
                                 int a1,
                                 LPCSCROLLINFO a2,
                                 BOOL a3)
{
    _PrintEnter("SetScrollInfo(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_SetScrollInfo(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetScrollInfo(,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetScrollPos(HWND a0,
                                int a1,
                                int a2,
                                BOOL a3)
{
    _PrintEnter("SetScrollPos(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_SetScrollPos(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetScrollPos(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetScrollRange(HWND a0,
                                   int a1,
                                   int a2,
                                   int a3,
                                   BOOL a4)
{
    _PrintEnter("SetScrollRange(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_SetScrollRange(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("SetScrollRange(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetStdHandle(DWORD a0,
                                 HANDLE a1)
{
    _PrintEnter("SetStdHandle(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetStdHandle(a0, a1);
    } __finally {
        _PrintExit("SetStdHandle(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetStretchBltMode(HDC a0,
                                     int a1)
{
    _PrintEnter("SetStretchBltMode(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_SetStretchBltMode(a0, a1);
    } __finally {
        _PrintExit("SetStretchBltMode(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetSysColors(int a0,
                                 INT* a1,
                                 COLORREF* a2)
{
    _PrintEnter("SetSysColors(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetSysColors(a0, a1, a2);
    } __finally {
        _PrintExit("SetSysColors(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetSystemCursor(HCURSOR a0,
                                    DWORD a1)
{
    _PrintEnter("SetSystemCursor(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetSystemCursor(a0, a1);
    } __finally {
        _PrintExit("SetSystemCursor(,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_SetSystemPaletteUse(HDC a0,
                                        UINT a1)
{
    _PrintEnter("SetSystemPaletteUse(%lx,%lx)\n", a0, a1);

    UINT rv = 0;
    __try {
        rv = Real_SetSystemPaletteUse(a0, a1);
    } __finally {
        _PrintExit("SetSystemPaletteUse(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetSystemPowerState(BOOL a0,
                                        BOOL a1)
{
    _PrintEnter("SetSystemPowerState(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetSystemPowerState(a0, a1);
    } __finally {
        _PrintExit("SetSystemPowerState(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetSystemTime(SYSTEMTIME* a0)
{
    _PrintEnter("SetSystemTime(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetSystemTime(a0);
    } __finally {
        _PrintExit("SetSystemTime() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetSystemTimeAdjustment(DWORD a0,
                                            BOOL a1)
{
    _PrintEnter("SetSystemTimeAdjustment(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetSystemTimeAdjustment(a0, a1);
    } __finally {
        _PrintExit("SetSystemTimeAdjustment(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_SetTapeParameters(HANDLE a0,
                                       DWORD a1,
                                       LPVOID a2)
{
    _PrintEnter("SetTapeParameters(%lx,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_SetTapeParameters(a0, a1, a2);
    } __finally {
        _PrintExit("SetTapeParameters(,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_SetTapePosition(HANDLE a0,
                                     DWORD a1,
                                     DWORD a2,
                                     DWORD a3,
                                     DWORD a4,
                                     BOOL a5)
{
    _PrintEnter("SetTapePosition(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    DWORD rv = 0;
    __try {
        rv = Real_SetTapePosition(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("SetTapePosition(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_SetTextAlign(HDC a0,
                                 UINT a1)
{
    _PrintEnter("SetTextAlign(%lx,%lx)\n", a0, a1);

    UINT rv = 0;
    __try {
        rv = Real_SetTextAlign(a0, a1);
    } __finally {
        _PrintExit("SetTextAlign(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetTextCharacterExtra(HDC a0,
                                         int a1)
{
    _PrintEnter("SetTextCharacterExtra(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_SetTextCharacterExtra(a0, a1);
    } __finally {
        _PrintExit("SetTextCharacterExtra(,) -> %lx\n", rv);
    };
    return rv;
}

COLORREF __stdcall Mine_SetTextColor(HDC a0,
                                     COLORREF a1)
{
    _PrintEnter("SetTextColor(%lx,%lx)\n", a0, a1);

    COLORREF rv = 0;
    __try {
        rv = Real_SetTextColor(a0, a1);
    } __finally {
        _PrintExit("SetTextColor(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetTextJustification(HDC a0,
                                         int a1,
                                         int a2)
{
    _PrintEnter("SetTextJustification(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetTextJustification(a0, a1, a2);
    } __finally {
        _PrintExit("SetTextJustification(,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_SetThreadAffinityMask(HANDLE a0,
                                           DWORD a1)
{
    _PrintEnter("SetThreadAffinityMask(%lx,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_SetThreadAffinityMask(a0, a1);
    } __finally {
        _PrintExit("SetThreadAffinityMask(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetThreadContext(HANDLE a0,
                                     CONTEXT* a1)
{
    _PrintEnter("SetThreadContext(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetThreadContext(a0, a1);
    } __finally {
        _PrintExit("SetThreadContext(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetThreadDesktop(HDESK a0)
{
    _PrintEnter("SetThreadDesktop(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetThreadDesktop(a0);
    } __finally {
        _PrintExit("SetThreadDesktop() -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_SetThreadIdealProcessor(HANDLE a0,
                                             DWORD a1)
{
    _PrintEnter("SetThreadIdealProcessor(%lx,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_SetThreadIdealProcessor(a0, a1);
    } __finally {
        _PrintExit("SetThreadIdealProcessor(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetThreadLocale(LCID a0)
{
    _PrintEnter("SetThreadLocale(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetThreadLocale(a0);
    } __finally {
        _PrintExit("SetThreadLocale() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetThreadPriority(HANDLE a0,
                                      int a1)
{
    _PrintEnter("SetThreadPriority(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetThreadPriority(a0, a1);
    } __finally {
        _PrintExit("SetThreadPriority(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetThreadPriorityBoost(HANDLE a0,
                                           BOOL a1)
{
    _PrintEnter("SetThreadPriorityBoost(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetThreadPriorityBoost(a0, a1);
    } __finally {
        _PrintExit("SetThreadPriorityBoost(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetTimeZoneInformation(TIME_ZONE_INFORMATION* a0)
{
    _PrintEnter("SetTimeZoneInformation(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SetTimeZoneInformation(a0);
    } __finally {
        _PrintExit("SetTimeZoneInformation() -> %lx\n", rv);
    };
    return rv;
}

UINT_PTR __stdcall Mine_SetTimer(HWND a0,
                                 UINT_PTR a1,
                                 UINT a2,
                                 TIMERPROC a3)
{
    _PrintEnter("SetTimer(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    UINT_PTR rv = 0;
    __try {
        rv = Real_SetTimer(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetTimer(,,,) -> %lx\n", rv);
    };
    return rv;
}

LPTOP_LEVEL_EXCEPTION_FILTER __stdcall Mine_SetUnhandledExceptionFilter(LPTOP_LEVEL_EXCEPTION_FILTER a0)
{
    _PrintEnter("SetUnhandledExceptionFilter(%lx)\n", a0);

    LPTOP_LEVEL_EXCEPTION_FILTER rv = 0;
    __try {
        rv = Real_SetUnhandledExceptionFilter(a0);
    } __finally {
        _PrintExit("SetUnhandledExceptionFilter() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetUserObjectInformationA(HANDLE a0,
                                              int a1,
                                              PVOID a2,
                                              DWORD a3)
{
    _PrintEnter("SetUserObjectInformationA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetUserObjectInformationA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetUserObjectInformationA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetUserObjectInformationW(HANDLE a0,
                                              int a1,
                                              PVOID a2,
                                              DWORD a3)
{
    _PrintEnter("SetUserObjectInformationW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetUserObjectInformationW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetUserObjectInformationW(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetUserObjectSecurity(HANDLE a0,
                                          PSECURITY_INFORMATION a1,
                                          PSECURITY_DESCRIPTOR a2)
{
    _PrintEnter("SetUserObjectSecurity(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetUserObjectSecurity(a0, a1, a2);
    } __finally {
        _PrintExit("SetUserObjectSecurity(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetViewportExtEx(HDC a0,
                                     int a1,
                                     int a2,
                                     struct tagSIZE* a3)
{
    _PrintEnter("SetViewportExtEx(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetViewportExtEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetViewportExtEx(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetViewportOrgEx(HDC a0,
                                     int a1,
                                     int a2,
                                     struct tagPOINT* a3)
{
    _PrintEnter("SetViewportOrgEx(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetViewportOrgEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetViewportOrgEx(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetVolumeLabelA(LPCSTR a0,
                                    LPCSTR a1)
{
    _PrintEnter("SetVolumeLabelA(%hs,%hs)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetVolumeLabelA(a0, a1);
    } __finally {
        _PrintExit("SetVolumeLabelA(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetVolumeLabelW(LPCWSTR a0,
                                    LPCWSTR a1)
{
    _PrintEnter("SetVolumeLabelW(%ls,%ls)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetVolumeLabelW(a0, a1);
    } __finally {
        _PrintExit("SetVolumeLabelW(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetWaitableTimer(HANDLE a0,
                                     LARGE_INTEGER* a1,
                                     LONG a2,
                                     PTIMERAPCROUTINE a3,
                                     LPVOID a4,
                                     BOOL a5)
{
    _PrintEnter("SetWaitableTimer(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_SetWaitableTimer(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("SetWaitableTimer(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HENHMETAFILE __stdcall Mine_SetWinMetaFileBits(UINT a0,
                                               BYTE* a1,
                                               HDC a2,
                                               struct tagMETAFILEPICT* a3)
{
    _PrintEnter("SetWinMetaFileBits(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HENHMETAFILE rv = 0;
    __try {
        rv = Real_SetWinMetaFileBits(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetWinMetaFileBits(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetWindowContextHelpId(HWND a0,
                                           DWORD a1)
{
    _PrintEnter("SetWindowContextHelpId(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetWindowContextHelpId(a0, a1);
    } __finally {
        _PrintExit("SetWindowContextHelpId(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetWindowExtEx(HDC a0,
                                   int a1,
                                   int a2,
                                   struct tagSIZE* a3)
{
    _PrintEnter("SetWindowExtEx(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetWindowExtEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetWindowExtEx(,,,) -> %lx\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_SetWindowLongA(HWND a0,
                                   int a1,
                                   LONG a2)
{
    _PrintEnter("SetWindowLongA(%lx,%lx,%lx)\n", a0, a1, a2);

    LONG rv = 0;
    __try {
        rv = Real_SetWindowLongA(a0, a1, a2);
    } __finally {
        _PrintExit("SetWindowLongA(,,) -> %lx\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_SetWindowLongW(HWND a0,
                                   int a1,
                                   LONG a2)
{
    _PrintEnter("SetWindowLongW(%lx,%lx,%lx)\n", a0, a1, a2);

    LONG rv = 0;
    __try {
        rv = Real_SetWindowLongW(a0, a1, a2);
    } __finally {
        _PrintExit("SetWindowLongW(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetWindowOrgEx(HDC a0,
                                   int a1,
                                   int a2,
                                   struct tagPOINT* a3)
{
    _PrintEnter("SetWindowOrgEx(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SetWindowOrgEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetWindowOrgEx(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetWindowPlacement(HWND a0,
                                       struct tagWINDOWPLACEMENT* a1)
{
    _PrintEnter("SetWindowPlacement(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetWindowPlacement(a0, a1);
    } __finally {
        _PrintExit("SetWindowPlacement(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetWindowPos(HWND a0,
                                 HWND a1,
                                 int a2,
                                 int a3,
                                 int a4,
                                 int a5,
                                 UINT a6)
{
    _PrintEnter("SetWindowPos(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_SetWindowPos(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("SetWindowPos(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_SetWindowRgn(HWND a0,
                                HRGN a1,
                                BOOL a2)
{
    _PrintEnter("SetWindowRgn(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_SetWindowRgn(a0, a1, a2);
    } __finally {
        _PrintExit("SetWindowRgn(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetWindowTextA(HWND a0,
                                   LPCSTR a1)
{
    _PrintEnter("SetWindowTextA(%lx,%hs)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetWindowTextA(a0, a1);
    } __finally {
        _PrintExit("SetWindowTextA(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetWindowTextW(HWND a0,
                                   LPCWSTR a1)
{
    _PrintEnter("SetWindowTextW(%lx,%ls)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetWindowTextW(a0, a1);
    } __finally {
        _PrintExit("SetWindowTextW(,) -> %lx\n", rv);
    };
    return rv;
}

WORD __stdcall Mine_SetWindowWord(HWND a0,
                                  int a1,
                                  WORD a2)
{
    _PrintEnter("SetWindowWord(%lx,%lx,%lx)\n", a0, a1, a2);

    WORD rv = 0;
    __try {
        rv = Real_SetWindowWord(a0, a1, a2);
    } __finally {
        _PrintExit("SetWindowWord(,,) -> %lx\n", rv);
    };
    return rv;
}

HHOOK __stdcall Mine_SetWindowsHookA(int a0,
                                     HOOKPROC a1)
{
    _PrintEnter("SetWindowsHookA(%lx,%lx)\n", a0, a1);

    HHOOK rv = 0;
    __try {
        rv = Real_SetWindowsHookA(a0, a1);
    } __finally {
        _PrintExit("SetWindowsHookA(,) -> %lx\n", rv);
    };
    return rv;
}

HHOOK __stdcall Mine_SetWindowsHookExA(int a0,
                                       HOOKPROC a1,
                                       HINSTANCE a2,
                                       DWORD a3)
{
    _PrintEnter("SetWindowsHookExA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HHOOK rv = 0;
    __try {
        rv = Real_SetWindowsHookExA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetWindowsHookExA(,,,) -> %lx\n", rv);
    };
    return rv;
}

HHOOK __stdcall Mine_SetWindowsHookExW(int a0,
                                       HOOKPROC a1,
                                       HINSTANCE a2,
                                       DWORD a3)
{
    _PrintEnter("SetWindowsHookExW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HHOOK rv = 0;
    __try {
        rv = Real_SetWindowsHookExW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SetWindowsHookExW(,,,) -> %lx\n", rv);
    };
    return rv;
}

HHOOK __stdcall Mine_SetWindowsHookW(int a0,
                                     HOOKPROC a1)
{
    _PrintEnter("SetWindowsHookW(%lx,%lx)\n", a0, a1);

    HHOOK rv = 0;
    __try {
        rv = Real_SetWindowsHookW(a0, a1);
    } __finally {
        _PrintExit("SetWindowsHookW(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetWorldTransform(HDC a0,
                                      XFORM* a1)
{
    _PrintEnter("SetWorldTransform(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SetWorldTransform(a0, a1);
    } __finally {
        _PrintExit("SetWorldTransform(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SetupComm(HANDLE a0,
                              DWORD a1,
                              DWORD a2)
{
    _PrintEnter("SetupComm(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SetupComm(a0, a1, a2);
    } __finally {
        _PrintExit("SetupComm(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ShowCaret(HWND a0)
{
    _PrintEnter("ShowCaret(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_ShowCaret(a0);
    } __finally {
        _PrintExit("ShowCaret() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_ShowCursor(BOOL a0)
{
    _PrintEnter("ShowCursor(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_ShowCursor(a0);
    } __finally {
        _PrintExit("ShowCursor() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ShowOwnedPopups(HWND a0,
                                    BOOL a1)
{
    _PrintEnter("ShowOwnedPopups(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_ShowOwnedPopups(a0, a1);
    } __finally {
        _PrintExit("ShowOwnedPopups(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ShowScrollBar(HWND a0,
                                  int a1,
                                  BOOL a2)
{
    _PrintEnter("ShowScrollBar(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_ShowScrollBar(a0, a1, a2);
    } __finally {
        _PrintExit("ShowScrollBar(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ShowWindow(HWND a0,
                               int a1)
{
    _PrintEnter("ShowWindow(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_ShowWindow(a0, a1);
    } __finally {
        _PrintExit("ShowWindow(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ShowWindowAsync(HWND a0,
                                    int a1)
{
    _PrintEnter("ShowWindowAsync(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_ShowWindowAsync(a0, a1);
    } __finally {
        _PrintExit("ShowWindowAsync(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_SignalObjectAndWait(HANDLE a0,
                                         HANDLE a1,
                                         DWORD a2,
                                         BOOL a3)
{
    _PrintEnter("SignalObjectAndWait(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    DWORD rv = 0;
    __try {
        rv = Real_SignalObjectAndWait(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SignalObjectAndWait(,,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_SizeofResource(HMODULE a0,
                                    HRSRC a1)
{
    _PrintEnter("SizeofResource(%lx,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_SizeofResource(a0, a1);
    } __finally {
        _PrintExit("SizeofResource(,) -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_Sleep(DWORD a0)
{
    _PrintEnter("Sleep(%lx)\n", a0);

    __try {
        Real_Sleep(a0);
    } __finally {
        _PrintExit("Sleep() ->\n");
    };
}

DWORD __stdcall Mine_SleepEx(DWORD a0,
                             BOOL a1)
{
    _PrintEnter("SleepEx(%lx,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_SleepEx(a0, a1);
    } __finally {
        _PrintExit("SleepEx(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_StartDocA(HDC a0,
                             DOCINFOA* a1)
{
    _PrintEnter("StartDocA(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_StartDocA(a0, a1);
    } __finally {
        _PrintExit("StartDocA(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_StartDocW(HDC a0,
                             DOCINFOW* a1)
{
    _PrintEnter("StartDocW(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_StartDocW(a0, a1);
    } __finally {
        _PrintExit("StartDocW(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_StartPage(HDC a0)
{
    _PrintEnter("StartPage(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_StartPage(a0);
    } __finally {
        _PrintExit("StartPage() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgCreateDocfile(OLECHAR* a0,
                                        DWORD a1,
                                        DWORD a2,
                                        IStorage** a3)
{
    _PrintEnter("StgCreateDocfile(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_StgCreateDocfile(a0, a1, a2, a3);
    } __finally {
        _PrintExit("StgCreateDocfile(,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgCreateDocfileOnILockBytes(ILockBytes* a0,
                                                    DWORD a1,
                                                    DWORD a2,
                                                    IStorage** a3)
{
    _PrintEnter("StgCreateDocfileOnILockBytes(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_StgCreateDocfileOnILockBytes(a0, a1, a2, a3);
    } __finally {
        _PrintExit("StgCreateDocfileOnILockBytes(,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgCreatePropSetStg(IStorage* a0,
                                           DWORD a1,
                                           IPropertySetStorage** a2)
{
    _PrintEnter("StgCreatePropSetStg(%lx,%lx,%lx)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_StgCreatePropSetStg(a0, a1, a2);
    } __finally {
        _PrintExit("StgCreatePropSetStg(,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgCreatePropStg(IUnknown* a0,
                                        IID& a1,
                                        CLSID* a2,
                                        DWORD a3,
                                        DWORD a4,
                                        IPropertyStorage** a5)
{
    _PrintEnter("StgCreatePropStg(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    HRESULT rv = 0;
    __try {
        rv = Real_StgCreatePropStg(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("StgCreatePropStg(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgCreateStorageEx(WCHAR* a0,
                                          DWORD a1,
                                          DWORD a2,
                                          DWORD a3,
                                          STGOPTIONS* a4,
                                          void* a5,
                                          IID& a6,
                                          void** a7)
{
    _PrintEnter("StgCreateStorageEx(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    HRESULT rv = 0;
    __try {
        rv = Real_StgCreateStorageEx(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("StgCreateStorageEx(,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgGetIFillLockBytesOnFile(OLECHAR* a0,
                                                  IFillLockBytes** a1)
{
    _PrintEnter("StgGetIFillLockBytesOnFile(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_StgGetIFillLockBytesOnFile(a0, a1);
    } __finally {
        _PrintExit("StgGetIFillLockBytesOnFile(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgGetIFillLockBytesOnILockBytes(ILockBytes* a0,
                                                        IFillLockBytes** a1)
{
    _PrintEnter("StgGetIFillLockBytesOnILockBytes(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_StgGetIFillLockBytesOnILockBytes(a0, a1);
    } __finally {
        _PrintExit("StgGetIFillLockBytesOnILockBytes(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgIsStorageFile(OLECHAR* a0)
{
    _PrintEnter("StgIsStorageFile(%lx)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_StgIsStorageFile(a0);
    } __finally {
        _PrintExit("StgIsStorageFile() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgIsStorageILockBytes(ILockBytes* a0)
{
    _PrintEnter("StgIsStorageILockBytes(%lx)\n", a0);

    HRESULT rv = 0;
    __try {
        rv = Real_StgIsStorageILockBytes(a0);
    } __finally {
        _PrintExit("StgIsStorageILockBytes() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgOpenAsyncDocfileOnIFillLockBytes(IFillLockBytes* a0,
                                                           DWORD a1,
                                                           DWORD a2,
                                                           IStorage** a3)
{
    _PrintEnter("StgOpenAsyncDocfileOnIFillLockBytes(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_StgOpenAsyncDocfileOnIFillLockBytes(a0, a1, a2, a3);
    } __finally {
        _PrintExit("StgOpenAsyncDocfileOnIFillLockBytes(,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgOpenPropStg(IUnknown* a0,
                                      IID& a1,
                                      DWORD a2,
                                      DWORD a3,
                                      IPropertyStorage** a4)
{
    _PrintEnter("StgOpenPropStg(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    HRESULT rv = 0;
    __try {
        rv = Real_StgOpenPropStg(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("StgOpenPropStg(,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgOpenStorage(OLECHAR* a0,
                                      IStorage* a1,
                                      DWORD a2,
                                      SNB a3,
                                      DWORD a4,
                                      IStorage** a5)
{
    _PrintEnter("StgOpenStorage(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    HRESULT rv = 0;
    __try {
        rv = Real_StgOpenStorage(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("StgOpenStorage(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgOpenStorageEx(WCHAR* a0,
                                        DWORD a1,
                                        DWORD a2,
                                        DWORD a3,
                                        STGOPTIONS* a4,
                                        void* a5,
                                        IID& a6,
                                        void** a7)
{
    _PrintEnter("StgOpenStorageEx(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    HRESULT rv = 0;
    __try {
        rv = Real_StgOpenStorageEx(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("StgOpenStorageEx(,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgOpenStorageOnILockBytes(ILockBytes* a0,
                                                  IStorage* a1,
                                                  DWORD a2,
                                                  SNB a3,
                                                  DWORD a4,
                                                  IStorage** a5)
{
    _PrintEnter("StgOpenStorageOnILockBytes(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    HRESULT rv = 0;
    __try {
        rv = Real_StgOpenStorageOnILockBytes(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("StgOpenStorageOnILockBytes(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StgSetTimes(OLECHAR* a0,
                                   FILETIME* a1,
                                   FILETIME* a2,
                                   FILETIME* a3)
{
    _PrintEnter("StgSetTimes(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    HRESULT rv = 0;
    __try {
        rv = Real_StgSetTimes(a0, a1, a2, a3);
    } __finally {
        _PrintExit("StgSetTimes(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_StretchBlt(HDC a0,
                               int a1,
                               int a2,
                               int a3,
                               int a4,
                               HDC a5,
                               int a6,
                               int a7,
                               int a8,
                               int a9,
                               DWORD a10)
{
    _PrintEnter("StretchBlt(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);

    BOOL rv = 0;
    __try {
        rv = Real_StretchBlt(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
    } __finally {
        _PrintExit("StretchBlt(,,,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_StretchDIBits(HDC a0,
                                 int a1,
                                 int a2,
                                 int a3,
                                 int a4,
                                 int a5,
                                 int a6,
                                 int a7,
                                 int a8,
                                 void* a9,
                                 struct tagBITMAPINFO* a10,
                                 UINT a11,
                                 DWORD a12)
{
    _PrintEnter("StretchDIBits(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);

    int rv = 0;
    __try {
        rv = Real_StretchDIBits(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
    } __finally {
        _PrintExit("StretchDIBits(,,,,,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StringFromCLSID(IID& a0,
                                       LPOLESTR* a1)
{
    _PrintEnter("StringFromCLSID(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_StringFromCLSID(a0, a1);
    } __finally {
        _PrintExit("StringFromCLSID(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_StringFromGUID2(GUID& a0,
                                   LPOLESTR a1,
                                   int a2)
{
    _PrintEnter("StringFromGUID2(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_StringFromGUID2(a0, a1, a2);
    } __finally {
        _PrintExit("StringFromGUID2(,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_StringFromIID(IID& a0,
                                     LPOLESTR* a1)
{
    _PrintEnter("StringFromIID(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_StringFromIID(a0, a1);
    } __finally {
        _PrintExit("StringFromIID(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_StrokeAndFillPath(HDC a0)
{
    _PrintEnter("StrokeAndFillPath(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_StrokeAndFillPath(a0);
    } __finally {
        _PrintExit("StrokeAndFillPath() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_StrokePath(HDC a0)
{
    _PrintEnter("StrokePath(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_StrokePath(a0);
    } __finally {
        _PrintExit("StrokePath() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SubtractRect(LPRECT a0,
                                 RECT* a1,
                                 RECT* a2)
{
    _PrintEnter("SubtractRect(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SubtractRect(a0, a1, a2);
    } __finally {
        _PrintExit("SubtractRect(,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_SuspendThread(HANDLE a0)
{
    _PrintEnter("SuspendThread(%lx)\n", a0);

    DWORD rv = 0;
    __try {
        rv = Real_SuspendThread(a0);
    } __finally {
        _PrintExit("SuspendThread() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SwapBuffers(HDC a0)
{
    _PrintEnter("SwapBuffers(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SwapBuffers(a0);
    } __finally {
        _PrintExit("SwapBuffers() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SwapMouseButton(BOOL a0)
{
    _PrintEnter("SwapMouseButton(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SwapMouseButton(a0);
    } __finally {
        _PrintExit("SwapMouseButton() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SwitchDesktop(HDESK a0)
{
    _PrintEnter("SwitchDesktop(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_SwitchDesktop(a0);
    } __finally {
        _PrintExit("SwitchDesktop() -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_SwitchToFiber(LPVOID a0)
{
    _PrintEnter("SwitchToFiber(%lx)\n", a0);

    __try {
        Real_SwitchToFiber(a0);
    } __finally {
        _PrintExit("SwitchToFiber() ->\n");
    };
}

BOOL __stdcall Mine_SwitchToThread(void)
{
    _PrintEnter("SwitchToThread()\n");

    BOOL rv = 0;
    __try {
        rv = Real_SwitchToThread();
    } __finally {
        _PrintExit("SwitchToThread() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SystemParametersInfoA(UINT a0,
                                          UINT a1,
                                          PVOID a2,
                                          UINT a3)
{
    _PrintEnter("SystemParametersInfoA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SystemParametersInfoA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SystemParametersInfoA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SystemParametersInfoW(UINT a0,
                                          UINT a1,
                                          PVOID a2,
                                          UINT a3)
{
    _PrintEnter("SystemParametersInfoW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_SystemParametersInfoW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("SystemParametersInfoW(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SystemTimeToFileTime(SYSTEMTIME* a0,
                                         LPFILETIME a1)
{
    _PrintEnter("SystemTimeToFileTime(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_SystemTimeToFileTime(a0, a1);
    } __finally {
        _PrintExit("SystemTimeToFileTime(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_SystemTimeToTzSpecificLocalTime(struct _TIME_ZONE_INFORMATION* a0,
                                                    struct _SYSTEMTIME* a1,
                                                    struct _SYSTEMTIME* a2)
{
    _PrintEnter("SystemTimeToTzSpecificLocalTime(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_SystemTimeToTzSpecificLocalTime(a0, a1, a2);
    } __finally {
        _PrintExit("SystemTimeToTzSpecificLocalTime(,,) -> %lx\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_TabbedTextOutA(HDC a0,
                                   int a1,
                                   int a2,
                                   LPCSTR a3,
                                   int a4,
                                   int a5,
                                   INT* a6,
                                   int a7)
{
    _PrintEnter("TabbedTextOutA(%lx,%lx,%lx,%hs,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    LONG rv = 0;
    __try {
        rv = Real_TabbedTextOutA(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("TabbedTextOutA(,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

LONG __stdcall Mine_TabbedTextOutW(HDC a0,
                                   int a1,
                                   int a2,
                                   LPCWSTR a3,
                                   int a4,
                                   int a5,
                                   INT* a6,
                                   int a7)
{
    _PrintEnter("TabbedTextOutW(%lx,%lx,%lx,%ls,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    LONG rv = 0;
    __try {
        rv = Real_TabbedTextOutW(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("TabbedTextOutW(,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_TerminateProcess(HANDLE a0,
                                     UINT a1)
{
    _PrintEnter("TerminateProcess(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_TerminateProcess(a0, a1);
    } __finally {
        _PrintExit("TerminateProcess(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_TerminateThread(HANDLE a0,
                                    DWORD a1)
{
    _PrintEnter("TerminateThread(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_TerminateThread(a0, a1);
    } __finally {
        _PrintExit("TerminateThread(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_TextOutA(HDC a0,
                             int a1,
                             int a2,
                             LPCSTR a3,
                             int a4)
{
    _PrintEnter("TextOutA(%lx,%lx,%lx,%hs,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_TextOutA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("TextOutA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_TextOutW(HDC a0,
                             int a1,
                             int a2,
                             LPCWSTR a3,
                             int a4)
{
    _PrintEnter("TextOutW(%lx,%lx,%lx,%ls,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_TextOutW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("TextOutW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

WORD __stdcall Mine_TileWindows(HWND a0,
                                UINT a1,
                                RECT* a2,
                                UINT a3,
                                struct HWND__** a4)
{
    _PrintEnter("TileWindows(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    WORD rv = 0;
    __try {
        rv = Real_TileWindows(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("TileWindows(,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_ToAscii(UINT a0,
                           UINT a1,
                           BYTE* a2,
                           LPWORD a3,
                           UINT a4)
{
    _PrintEnter("ToAscii(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_ToAscii(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("ToAscii(,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_ToAsciiEx(UINT a0,
                             UINT a1,
                             BYTE* a2,
                             LPWORD a3,
                             UINT a4,
                             HKL a5)
{
    _PrintEnter("ToAsciiEx(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_ToAsciiEx(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("ToAsciiEx(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_ToUnicode(UINT a0,
                             UINT a1,
                             BYTE* a2,
                             LPWSTR a3,
                             int a4,
                             UINT a5)
{
    _PrintEnter("ToUnicode(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_ToUnicode(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("ToUnicode(,,,%ls,,) -> %lx\n", a3, rv);
    };
    return rv;
}

int __stdcall Mine_ToUnicodeEx(UINT a0,
                               UINT a1,
                               BYTE* a2,
                               LPWSTR a3,
                               int a4,
                               UINT a5,
                               HKL a6)
{
    _PrintEnter("ToUnicodeEx(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    int rv = 0;
    __try {
        rv = Real_ToUnicodeEx(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("ToUnicodeEx(,,,%ls,,,) -> %lx\n", a3, rv);
    };
    return rv;
}

BOOL __stdcall Mine_TrackMouseEvent(struct tagTRACKMOUSEEVENT* a0)
{
    _PrintEnter("TrackMouseEvent(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_TrackMouseEvent(a0);
    } __finally {
        _PrintExit("TrackMouseEvent() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_TrackPopupMenu(HMENU a0,
                                   UINT a1,
                                   int a2,
                                   int a3,
                                   int a4,
                                   HWND a5,
                                   RECT* a6)
{
    _PrintEnter("TrackPopupMenu(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_TrackPopupMenu(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("TrackPopupMenu(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_TrackPopupMenuEx(HMENU a0,
                                     UINT a1,
                                     int a2,
                                     int a3,
                                     HWND a4,
                                     LPTPMPARAMS a5)
{
    _PrintEnter("TrackPopupMenuEx(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_TrackPopupMenuEx(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("TrackPopupMenuEx(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_TransactNamedPipe(HANDLE a0,
                                      LPVOID a1,
                                      DWORD a2,
                                      LPVOID a3,
                                      DWORD a4,
                                      LPDWORD a5,
                                      LPOVERLAPPED a6)
{
    _PrintEnter("TransactNamedPipe(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    BOOL rv = 0;
    __try {
        rv = Real_TransactNamedPipe(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("TransactNamedPipe(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_TranslateAcceleratorA(HWND a0,
                                         HACCEL a1,
                                         LPMSG a2)
{
    _PrintEnter("TranslateAcceleratorA(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_TranslateAcceleratorA(a0, a1, a2);
    } __finally {
        _PrintExit("TranslateAcceleratorA(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_TranslateAcceleratorW(HWND a0,
                                         HACCEL a1,
                                         LPMSG a2)
{
    _PrintEnter("TranslateAcceleratorW(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_TranslateAcceleratorW(a0, a1, a2);
    } __finally {
        _PrintExit("TranslateAcceleratorW(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_TranslateCharsetInfo(DWORD* a0,
                                         struct tagCHARSETINFO* a1,
                                         DWORD a2)
{
    _PrintEnter("TranslateCharsetInfo(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_TranslateCharsetInfo(a0, a1, a2);
    } __finally {
        _PrintExit("TranslateCharsetInfo(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_TranslateMDISysAccel(HWND a0,
                                         LPMSG a1)
{
    _PrintEnter("TranslateMDISysAccel(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_TranslateMDISysAccel(a0, a1);
    } __finally {
        _PrintExit("TranslateMDISysAccel(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_TranslateMessage(struct tagMSG* a0)
{
    _PrintEnter("TranslateMessage(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_TranslateMessage(a0);
    } __finally {
        _PrintExit("TranslateMessage() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_TransmitCommChar(HANDLE a0,
                                     char a1)
{
    _PrintEnter("TransmitCommChar(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_TransmitCommChar(a0, a1);
    } __finally {
        _PrintExit("TransmitCommChar(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_TryEnterCriticalSection(LPCRITICAL_SECTION a0)
{
    _PrintEnter("TryEnterCriticalSection(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_TryEnterCriticalSection(a0);
    } __finally {
        _PrintExit("TryEnterCriticalSection() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UnhookWindowsHook(int a0,
                                      HOOKPROC a1)
{
    _PrintEnter("UnhookWindowsHook(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_UnhookWindowsHook(a0, a1);
    } __finally {
        _PrintExit("UnhookWindowsHook(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UnhookWindowsHookEx(HHOOK a0)
{
    _PrintEnter("UnhookWindowsHookEx(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_UnhookWindowsHookEx(a0);
    } __finally {
        _PrintExit("UnhookWindowsHookEx() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UnionRect(LPRECT a0,
                              RECT* a1,
                              RECT* a2)
{
    _PrintEnter("UnionRect(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_UnionRect(a0, a1, a2);
    } __finally {
        _PrintExit("UnionRect(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UnloadKeyboardLayout(HKL a0)
{
    _PrintEnter("UnloadKeyboardLayout(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_UnloadKeyboardLayout(a0);
    } __finally {
        _PrintExit("UnloadKeyboardLayout() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UnlockFile(HANDLE a0,
                               DWORD a1,
                               DWORD a2,
                               DWORD a3,
                               DWORD a4)
{
    _PrintEnter("UnlockFile(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_UnlockFile(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("UnlockFile(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UnlockFileEx(HANDLE a0,
                                 DWORD a1,
                                 DWORD a2,
                                 DWORD a3,
                                 LPOVERLAPPED a4)
{
    _PrintEnter("UnlockFileEx(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_UnlockFileEx(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("UnlockFileEx(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UnmapViewOfFile(LPCVOID a0)
{
    _PrintEnter("UnmapViewOfFile(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_UnmapViewOfFile(a0);
    } __finally {
        _PrintExit("UnmapViewOfFile() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UnpackDDElParam(UINT a0,
                                    LPARAM a1,
                                    PUINT_PTR a2,
                                    PUINT_PTR a3)
{
    _PrintEnter("UnpackDDElParam(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_UnpackDDElParam(a0, a1, a2, a3);
    } __finally {
        _PrintExit("UnpackDDElParam(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UnrealizeObject(HGDIOBJ a0)
{
    _PrintEnter("UnrealizeObject(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_UnrealizeObject(a0);
    } __finally {
        _PrintExit("UnrealizeObject() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UnregisterClassA(LPCSTR a0,
                                     HINSTANCE a1)
{
    _PrintEnter("UnregisterClassA(%hs,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_UnregisterClassA(a0, a1);
    } __finally {
        _PrintExit("UnregisterClassA(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UnregisterClassW(LPCWSTR a0,
                                     HINSTANCE a1)
{
    _PrintEnter("UnregisterClassW(%ls,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_UnregisterClassW(a0, a1);
    } __finally {
        _PrintExit("UnregisterClassW(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UnregisterHotKey(HWND a0,
                                     int a1)
{
    _PrintEnter("UnregisterHotKey(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_UnregisterHotKey(a0, a1);
    } __finally {
        _PrintExit("UnregisterHotKey(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UpdateColors(HDC a0)
{
    _PrintEnter("UpdateColors(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_UpdateColors(a0);
    } __finally {
        _PrintExit("UpdateColors() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UpdateICMRegKeyA(DWORD a0,
                                     LPSTR a1,
                                     LPSTR a2,
                                     UINT a3)
{
    _PrintEnter("UpdateICMRegKeyA(%lx,%hs,%hs,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_UpdateICMRegKeyA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("UpdateICMRegKeyA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UpdateICMRegKeyW(DWORD a0,
                                     LPWSTR a1,
                                     LPWSTR a2,
                                     UINT a3)
{
    _PrintEnter("UpdateICMRegKeyW(%lx,%ls,%ls,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_UpdateICMRegKeyW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("UpdateICMRegKeyW(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UpdateResourceA(HANDLE a0,
                                    LPCSTR a1,
                                    LPCSTR a2,
                                    WORD a3,
                                    LPVOID a4,
                                    DWORD a5)
{
    _PrintEnter("UpdateResourceA(%lx,%hs,%hs,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_UpdateResourceA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("UpdateResourceA(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UpdateResourceW(HANDLE a0,
                                    LPCWSTR a1,
                                    LPCWSTR a2,
                                    WORD a3,
                                    LPVOID a4,
                                    DWORD a5)
{
    _PrintEnter("UpdateResourceW(%lx,%ls,%ls,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    BOOL rv = 0;
    __try {
        rv = Real_UpdateResourceW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("UpdateResourceW(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_UpdateWindow(HWND a0)
{
    _PrintEnter("UpdateWindow(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_UpdateWindow(a0);
    } __finally {
        _PrintExit("UpdateWindow() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ValidateRect(HWND a0,
                                 RECT* a1)
{
    _PrintEnter("ValidateRect(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_ValidateRect(a0, a1);
    } __finally {
        _PrintExit("ValidateRect(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_ValidateRgn(HWND a0,
                                HRGN a1)
{
    _PrintEnter("ValidateRgn(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_ValidateRgn(a0, a1);
    } __finally {
        _PrintExit("ValidateRgn(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_VerLanguageNameA(DWORD a0,
                                      LPSTR a1,
                                      DWORD a2)
{
    _PrintEnter("VerLanguageNameA(%lx,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_VerLanguageNameA(a0, a1, a2);
    } __finally {
        _PrintExit("VerLanguageNameA(,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_VerLanguageNameW(DWORD a0,
                                      LPWSTR a1,
                                      DWORD a2)
{
    _PrintEnter("VerLanguageNameW(%lx,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_VerLanguageNameW(a0, a1, a2);
    } __finally {
        _PrintExit("VerLanguageNameW(,,) -> %lx\n", rv);
    };
    return rv;
}

LPVOID __stdcall Mine_VirtualAllocEx(HANDLE a0,
                                     LPVOID a1,
                                     SIZE_T a2,
                                     DWORD a3,
                                     DWORD a4)
{
    _PrintEnter("VirtualAllocEx(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    LPVOID rv = 0;
    __try {
        rv = Real_VirtualAllocEx(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("VirtualAllocEx(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_VirtualFreeEx(HANDLE a0,
                                  LPVOID a1,
                                  SIZE_T a2,
                                  DWORD a3)
{
    _PrintEnter("VirtualFreeEx(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_VirtualFreeEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("VirtualFreeEx(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_VirtualProtectEx(HANDLE a0,
                                     LPVOID a1,
                                     SIZE_T a2,
                                     DWORD a3,
                                     PDWORD a4)
{
    _PrintEnter("VirtualProtectEx(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_VirtualProtectEx(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("VirtualProtectEx(,,,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_VirtualQueryEx(HANDLE a0,
                                    LPCVOID a1,
                                    struct _MEMORY_BASIC_INFORMATION* a2,
                                    DWORD a3)
{
    _PrintEnter("VirtualQueryEx(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    DWORD rv = 0;
    __try {
        rv = Real_VirtualQueryEx(a0, a1, a2, a3);
    } __finally {
        _PrintExit("VirtualQueryEx(,,,) -> %lx\n", rv);
    };
    return rv;
}

SHORT __stdcall Mine_VkKeyScanA(CHAR a0)
{
    _PrintEnter("VkKeyScanA(%lx)\n", a0);

    SHORT rv = 0;
    __try {
        rv = Real_VkKeyScanA(a0);
    } __finally {
        _PrintExit("VkKeyScanA() -> %lx\n", rv);
    };
    return rv;
}

SHORT __stdcall Mine_VkKeyScanExA(CHAR a0,
                                  HKL a1)
{
    _PrintEnter("VkKeyScanExA(%lx,%lx)\n", a0, a1);

    SHORT rv = 0;
    __try {
        rv = Real_VkKeyScanExA(a0, a1);
    } __finally {
        _PrintExit("VkKeyScanExA(,) -> %lx\n", rv);
    };
    return rv;
}

SHORT __stdcall Mine_VkKeyScanExW(WCHAR a0,
                                  HKL a1)
{
    _PrintEnter("VkKeyScanExW(%lx,%lx)\n", a0, a1);

    SHORT rv = 0;
    __try {
        rv = Real_VkKeyScanExW(a0, a1);
    } __finally {
        _PrintExit("VkKeyScanExW(,) -> %lx\n", rv);
    };
    return rv;
}

SHORT __stdcall Mine_VkKeyScanW(WCHAR a0)
{
    _PrintEnter("VkKeyScanW(%lx)\n", a0);

    SHORT rv = 0;
    __try {
        rv = Real_VkKeyScanW(a0);
    } __finally {
        _PrintExit("VkKeyScanW() -> %lx\n", rv);
    };
    return rv;
}

SOCKET __stdcall Mine_WSAAccept(SOCKET a0,
                                sockaddr* a1,
                                LPINT a2,
                                LPCONDITIONPROC a3,
                                DWORD a4)
{
    _PrintEnter("WSAAccept(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    SOCKET rv = 0;
    __try {
        rv = Real_WSAAccept(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WSAAccept(,,,,) -> %lx\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAAddressToStringA(LPSOCKADDR a0,
                                       DWORD a1,
                                       struct _WSAPROTOCOL_INFOA* a2,
                                       LPSTR a3,
                                       LPDWORD a4)
{
    _PrintEnter("WSAAddressToStringA(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    INT rv = 0;
    __try {
        rv = Real_WSAAddressToStringA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WSAAddressToStringA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAAddressToStringW(LPSOCKADDR a0,
                                       DWORD a1,
                                       struct _WSAPROTOCOL_INFOW* a2,
                                       LPWSTR a3,
                                       LPDWORD a4)
{
    _PrintEnter("WSAAddressToStringW(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    INT rv = 0;
    __try {
        rv = Real_WSAAddressToStringW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WSAAddressToStringW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_WSAAsyncGetHostByAddr(HWND a0,
                                            u_int a1,
                                            char* a2,
                                            int a3,
                                            int a4,
                                            char* a5,
                                            int a6)
{
    _PrintEnter("WSAAsyncGetHostByAddr(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    HANDLE rv = 0;
    __try {
        rv = Real_WSAAsyncGetHostByAddr(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("WSAAsyncGetHostByAddr(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_WSAAsyncGetHostByName(HWND a0,
                                            u_int a1,
                                            char* a2,
                                            char* a3,
                                            int a4)
{
    _PrintEnter("WSAAsyncGetHostByName(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    HANDLE rv = 0;
    __try {
        rv = Real_WSAAsyncGetHostByName(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WSAAsyncGetHostByName(,,,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_WSAAsyncGetProtoByName(HWND a0,
                                             u_int a1,
                                             char* a2,
                                             char* a3,
                                             int a4)
{
    _PrintEnter("WSAAsyncGetProtoByName(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    HANDLE rv = 0;
    __try {
        rv = Real_WSAAsyncGetProtoByName(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WSAAsyncGetProtoByName(,,,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_WSAAsyncGetProtoByNumber(HWND a0,
                                               u_int a1,
                                               int a2,
                                               char* a3,
                                               int a4)
{
    _PrintEnter("WSAAsyncGetProtoByNumber(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    HANDLE rv = 0;
    __try {
        rv = Real_WSAAsyncGetProtoByNumber(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WSAAsyncGetProtoByNumber(,,,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_WSAAsyncGetServByName(HWND a0,
                                            u_int a1,
                                            char* a2,
                                            char* a3,
                                            char* a4,
                                            int a5)
{
    _PrintEnter("WSAAsyncGetServByName(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    HANDLE rv = 0;
    __try {
        rv = Real_WSAAsyncGetServByName(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("WSAAsyncGetServByName(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_WSAAsyncGetServByPort(HWND a0,
                                            u_int a1,
                                            int a2,
                                            char* a3,
                                            char* a4,
                                            int a5)
{
    _PrintEnter("WSAAsyncGetServByPort(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    HANDLE rv = 0;
    __try {
        rv = Real_WSAAsyncGetServByPort(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("WSAAsyncGetServByPort(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSAAsyncSelect(SOCKET a0,
                                  HWND a1,
                                  u_int a2,
                                  long a3)
{
    _PrintEnter("WSAAsyncSelect(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_WSAAsyncSelect(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WSAAsyncSelect(,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSACancelAsyncRequest(HANDLE a0)
{
    _PrintEnter("WSACancelAsyncRequest(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_WSACancelAsyncRequest(a0);
    } __finally {
        _PrintExit("WSACancelAsyncRequest() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSACancelBlockingCall(void)
{
    _PrintEnter("WSACancelBlockingCall()\n");

    int rv = 0;
    __try {
        rv = Real_WSACancelBlockingCall();
    } __finally {
        _PrintExit("WSACancelBlockingCall() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSACleanup(void)
{
    _PrintEnter("WSACleanup()\n");

    int rv = 0;
    __try {
        rv = Real_WSACleanup();
    } __finally {
        _PrintExit("WSACleanup() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WSACloseEvent(HANDLE a0)
{
    _PrintEnter("WSACloseEvent(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_WSACloseEvent(a0);
    } __finally {
        _PrintExit("WSACloseEvent() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSAConnect(SOCKET a0,
                              sockaddr* a1,
                              int a2,
                              LPWSABUF a3,
                              LPWSABUF a4,
                              LPQOS a5,
                              LPQOS a6)
{
    _PrintEnter("WSAConnect(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    int rv = 0;
    __try {
        rv = Real_WSAConnect(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("WSAConnect(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

HANDLE __stdcall Mine_WSACreateEvent(void)
{
    _PrintEnter("WSACreateEvent()\n");

    HANDLE rv = 0;
    __try {
        rv = Real_WSACreateEvent();
    } __finally {
        _PrintExit("WSACreateEvent() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSADuplicateSocketA(SOCKET a0,
                                       DWORD a1,
                                       struct _WSAPROTOCOL_INFOA* a2)
{
    _PrintEnter("WSADuplicateSocketA(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_WSADuplicateSocketA(a0, a1, a2);
    } __finally {
        _PrintExit("WSADuplicateSocketA(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSADuplicateSocketW(SOCKET a0,
                                       DWORD a1,
                                       struct _WSAPROTOCOL_INFOW* a2)
{
    _PrintEnter("WSADuplicateSocketW(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_WSADuplicateSocketW(a0, a1, a2);
    } __finally {
        _PrintExit("WSADuplicateSocketW(,,) -> %lx\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAEnumNameSpaceProvidersA(LPDWORD a0,
                                              LPWSANAMESPACE_INFOA a1)
{
    _PrintEnter("WSAEnumNameSpaceProvidersA(%lx,%lx)\n", a0, a1);

    INT rv = 0;
    __try {
        rv = Real_WSAEnumNameSpaceProvidersA(a0, a1);
    } __finally {
        _PrintExit("WSAEnumNameSpaceProvidersA(,) -> %lx\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAEnumNameSpaceProvidersW(LPDWORD a0,
                                              LPWSANAMESPACE_INFOW a1)
{
    _PrintEnter("WSAEnumNameSpaceProvidersW(%lx,%lx)\n", a0, a1);

    INT rv = 0;
    __try {
        rv = Real_WSAEnumNameSpaceProvidersW(a0, a1);
    } __finally {
        _PrintExit("WSAEnumNameSpaceProvidersW(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSAEnumNetworkEvents(SOCKET a0,
                                        HANDLE a1,
                                        LPWSANETWORKEVENTS a2)
{
    _PrintEnter("WSAEnumNetworkEvents(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_WSAEnumNetworkEvents(a0, a1, a2);
    } __finally {
        _PrintExit("WSAEnumNetworkEvents(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSAEnumProtocolsA(LPINT a0,
                                     struct _WSAPROTOCOL_INFOA* a1,
                                     LPDWORD a2)
{
    _PrintEnter("WSAEnumProtocolsA(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_WSAEnumProtocolsA(a0, a1, a2);
    } __finally {
        _PrintExit("WSAEnumProtocolsA(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSAEnumProtocolsW(LPINT a0,
                                     struct _WSAPROTOCOL_INFOW* a1,
                                     LPDWORD a2)
{
    _PrintEnter("WSAEnumProtocolsW(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_WSAEnumProtocolsW(a0, a1, a2);
    } __finally {
        _PrintExit("WSAEnumProtocolsW(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSAEventSelect(SOCKET a0,
                                  HANDLE a1,
                                  long a2)
{
    _PrintEnter("WSAEventSelect(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_WSAEventSelect(a0, a1, a2);
    } __finally {
        _PrintExit("WSAEventSelect(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WSAGetOverlappedResult(SOCKET a0,
                                           LPWSAOVERLAPPED a1,
                                           LPDWORD a2,
                                           BOOL a3,
                                           LPDWORD a4)
{
    _PrintEnter("WSAGetOverlappedResult(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WSAGetOverlappedResult(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WSAGetOverlappedResult(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WSAGetQOSByName(SOCKET a0,
                                    LPWSABUF a1,
                                    LPQOS a2)
{
    _PrintEnter("WSAGetQOSByName(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_WSAGetQOSByName(a0, a1, a2);
    } __finally {
        _PrintExit("WSAGetQOSByName(,,) -> %lx\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAGetServiceClassInfoA(LPGUID a0,
                                           LPGUID a1,
                                           LPDWORD a2,
                                           struct _WSAServiceClassInfoA* a3)
{
    _PrintEnter("WSAGetServiceClassInfoA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    INT rv = 0;
    __try {
        rv = Real_WSAGetServiceClassInfoA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WSAGetServiceClassInfoA(,,,) -> %lx\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAGetServiceClassInfoW(LPGUID a0,
                                           LPGUID a1,
                                           LPDWORD a2,
                                           struct _WSAServiceClassInfoW* a3)
{
    _PrintEnter("WSAGetServiceClassInfoW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    INT rv = 0;
    __try {
        rv = Real_WSAGetServiceClassInfoW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WSAGetServiceClassInfoW(,,,) -> %lx\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAGetServiceClassNameByClassIdA(LPGUID a0,
                                                    LPSTR a1,
                                                    LPDWORD a2)
{
    _PrintEnter("WSAGetServiceClassNameByClassIdA(%lx,%lx,%lx)\n", a0, a1, a2);

    INT rv = 0;
    __try {
        rv = Real_WSAGetServiceClassNameByClassIdA(a0, a1, a2);
    } __finally {
        _PrintExit("WSAGetServiceClassNameByClassIdA(,,) -> %lx\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAGetServiceClassNameByClassIdW(LPGUID a0,
                                                    LPWSTR a1,
                                                    LPDWORD a2)
{
    _PrintEnter("WSAGetServiceClassNameByClassIdW(%lx,%lx,%lx)\n", a0, a1, a2);

    INT rv = 0;
    __try {
        rv = Real_WSAGetServiceClassNameByClassIdW(a0, a1, a2);
    } __finally {
        _PrintExit("WSAGetServiceClassNameByClassIdW(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSAHtonl(SOCKET a0,
                            u_long a1,
                            u_long* a2)
{
    _PrintEnter("WSAHtonl(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_WSAHtonl(a0, a1, a2);
    } __finally {
        _PrintExit("WSAHtonl(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSAHtons(SOCKET a0,
                            u_short a1,
                            u_short* a2)
{
    _PrintEnter("WSAHtons(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_WSAHtons(a0, a1, a2);
    } __finally {
        _PrintExit("WSAHtons(,,) -> %lx\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAInstallServiceClassA(struct _WSAServiceClassInfoA* a0)
{
    _PrintEnter("WSAInstallServiceClassA(%lx)\n", a0);

    INT rv = 0;
    __try {
        rv = Real_WSAInstallServiceClassA(a0);
    } __finally {
        _PrintExit("WSAInstallServiceClassA() -> %lx\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAInstallServiceClassW(struct _WSAServiceClassInfoW* a0)
{
    _PrintEnter("WSAInstallServiceClassW(%lx)\n", a0);

    INT rv = 0;
    __try {
        rv = Real_WSAInstallServiceClassW(a0);
    } __finally {
        _PrintExit("WSAInstallServiceClassW() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSAIoctl(SOCKET a0,
                            DWORD a1,
                            LPVOID a2,
                            DWORD a3,
                            LPVOID a4,
                            DWORD a5,
                            LPDWORD a6,
                            LPWSAOVERLAPPED a7,
                            LPWSAOVERLAPPED_COMPLETION_ROUTINE a8)
{
    _PrintEnter("WSAIoctl(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8);

    int rv = 0;
    __try {
        rv = Real_WSAIoctl(a0, a1, a2, a3, a4, a5, a6, a7, a8);
    } __finally {
        _PrintExit("WSAIoctl(,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WSAIsBlocking(void)
{
    _PrintEnter("WSAIsBlocking()\n");

    BOOL rv = 0;
    __try {
        rv = Real_WSAIsBlocking();
    } __finally {
        _PrintExit("WSAIsBlocking() -> %lx\n", rv);
    };
    return rv;
}

SOCKET __stdcall Mine_WSAJoinLeaf(SOCKET a0,
                                  sockaddr* a1,
                                  int a2,
                                  LPWSABUF a3,
                                  LPWSABUF a4,
                                  LPQOS a5,
                                  LPQOS a6,
                                  DWORD a7)
{
    _PrintEnter("WSAJoinLeaf(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7);

    SOCKET rv = 0;
    __try {
        rv = Real_WSAJoinLeaf(a0, a1, a2, a3, a4, a5, a6, a7);
    } __finally {
        _PrintExit("WSAJoinLeaf(,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSALookupServiceBeginA(struct _WSAQuerySetA* a0,
                                          DWORD a1,
                                          LPHANDLE a2)
{
    _PrintEnter("WSALookupServiceBeginA(%lx,%lx,%lx)\n", a0, a1, a2);

    INT rv = 0;
    __try {
        rv = Real_WSALookupServiceBeginA(a0, a1, a2);
    } __finally {
        _PrintExit("WSALookupServiceBeginA(,,) -> %lx\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSALookupServiceBeginW(struct _WSAQuerySetW* a0,
                                          DWORD a1,
                                          LPHANDLE a2)
{
    _PrintEnter("WSALookupServiceBeginW(%lx,%lx,%lx)\n", a0, a1, a2);

    INT rv = 0;
    __try {
        rv = Real_WSALookupServiceBeginW(a0, a1, a2);
    } __finally {
        _PrintExit("WSALookupServiceBeginW(,,) -> %lx\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSALookupServiceEnd(HANDLE a0)
{
    _PrintEnter("WSALookupServiceEnd(%lx)\n", a0);

    INT rv = 0;
    __try {
        rv = Real_WSALookupServiceEnd(a0);
    } __finally {
        _PrintExit("WSALookupServiceEnd() -> %lx\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSALookupServiceNextA(HANDLE a0,
                                         DWORD a1,
                                         LPDWORD a2,
                                         struct _WSAQuerySetA* a3)
{
    _PrintEnter("WSALookupServiceNextA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    INT rv = 0;
    __try {
        rv = Real_WSALookupServiceNextA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WSALookupServiceNextA(,,,) -> %lx\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSALookupServiceNextW(HANDLE a0,
                                         DWORD a1,
                                         LPDWORD a2,
                                         struct _WSAQuerySetW* a3)
{
    _PrintEnter("WSALookupServiceNextW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    INT rv = 0;
    __try {
        rv = Real_WSALookupServiceNextW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WSALookupServiceNextW(,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSANtohl(SOCKET a0,
                            u_long a1,
                            u_long* a2)
{
    _PrintEnter("WSANtohl(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_WSANtohl(a0, a1, a2);
    } __finally {
        _PrintExit("WSANtohl(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSANtohs(SOCKET a0,
                            u_short a1,
                            u_short* a2)
{
    _PrintEnter("WSANtohs(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_WSANtohs(a0, a1, a2);
    } __finally {
        _PrintExit("WSANtohs(,,) -> %lx\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAProviderConfigChange(LPHANDLE a0,
                                           LPWSAOVERLAPPED a1,
                                           LPWSAOVERLAPPED_COMPLETION_ROUTINE a2)
{
    _PrintEnter("WSAProviderConfigChange(%lx,%lx,%lx)\n", a0, a1, a2);

    INT rv = 0;
    __try {
        rv = Real_WSAProviderConfigChange(a0, a1, a2);
    } __finally {
        _PrintExit("WSAProviderConfigChange(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSARecv(SOCKET a0,
                           LPWSABUF a1,
                           DWORD a2,
                           LPDWORD a3,
                           LPDWORD a4,
                           LPWSAOVERLAPPED a5,
                           LPWSAOVERLAPPED_COMPLETION_ROUTINE a6)
{
    _PrintEnter("WSARecv(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    int rv = 0;
    __try {
        rv = Real_WSARecv(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("WSARecv(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSARecvDisconnect(SOCKET a0,
                                     LPWSABUF a1)
{
    _PrintEnter("WSARecvDisconnect(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_WSARecvDisconnect(a0, a1);
    } __finally {
        _PrintExit("WSARecvDisconnect(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSARecvFrom(SOCKET a0,
                               LPWSABUF a1,
                               DWORD a2,
                               LPDWORD a3,
                               LPDWORD a4,
                               sockaddr* a5,
                               LPINT a6,
                               LPWSAOVERLAPPED a7,
                               LPWSAOVERLAPPED_COMPLETION_ROUTINE a8)
{
    _PrintEnter("WSARecvFrom(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8);

    int rv = 0;
    __try {
        rv = Real_WSARecvFrom(a0, a1, a2, a3, a4, a5, a6, a7, a8);
    } __finally {
        _PrintExit("WSARecvFrom(,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSARemoveServiceClass(LPGUID a0)
{
    _PrintEnter("WSARemoveServiceClass(%lx)\n", a0);

    INT rv = 0;
    __try {
        rv = Real_WSARemoveServiceClass(a0);
    } __finally {
        _PrintExit("WSARemoveServiceClass() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WSAResetEvent(HANDLE a0)
{
    _PrintEnter("WSAResetEvent(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_WSAResetEvent(a0);
    } __finally {
        _PrintExit("WSAResetEvent() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSASend(SOCKET a0,
                           LPWSABUF a1,
                           DWORD a2,
                           LPDWORD a3,
                           DWORD a4,
                           LPWSAOVERLAPPED a5,
                           LPWSAOVERLAPPED_COMPLETION_ROUTINE a6)
{
    _PrintEnter("WSASend(%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6);

    int rv = 0;
    __try {
        rv = Real_WSASend(a0, a1, a2, a3, a4, a5, a6);
    } __finally {
        _PrintExit("WSASend(,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSASendDisconnect(SOCKET a0,
                                     LPWSABUF a1)
{
    _PrintEnter("WSASendDisconnect(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_WSASendDisconnect(a0, a1);
    } __finally {
        _PrintExit("WSASendDisconnect(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSASendTo(SOCKET a0,
                             LPWSABUF a1,
                             DWORD a2,
                             LPDWORD a3,
                             DWORD a4,
                             sockaddr* a5,
                             int a6,
                             LPWSAOVERLAPPED a7,
                             LPWSAOVERLAPPED_COMPLETION_ROUTINE a8)
{
    _PrintEnter("WSASendTo(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5, a6, a7, a8);

    int rv = 0;
    __try {
        rv = Real_WSASendTo(a0, a1, a2, a3, a4, a5, a6, a7, a8);
    } __finally {
        _PrintExit("WSASendTo(,,,,,,,,) -> %lx\n", rv);
    };
    return rv;
}

FARPROC __stdcall Mine_WSASetBlockingHook(FARPROC a0)
{
    _PrintEnter("WSASetBlockingHook(%lx)\n", a0);

    FARPROC rv = 0;
    __try {
        rv = Real_WSASetBlockingHook(a0);
    } __finally {
        _PrintExit("WSASetBlockingHook() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WSASetEvent(HANDLE a0)
{
    _PrintEnter("WSASetEvent(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_WSASetEvent(a0);
    } __finally {
        _PrintExit("WSASetEvent() -> %lx\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSASetServiceA(struct _WSAQuerySetA* a0,
                                  WSAESETSERVICEOP a1,
                                  DWORD a2)
{
    _PrintEnter("WSASetServiceA(%lx,%lx,%lx)\n", a0, a1, a2);

    INT rv = 0;
    __try {
        rv = Real_WSASetServiceA(a0, a1, a2);
    } __finally {
        _PrintExit("WSASetServiceA(,,) -> %lx\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSASetServiceW(struct _WSAQuerySetW* a0,
                                  WSAESETSERVICEOP a1,
                                  DWORD a2)
{
    _PrintEnter("WSASetServiceW(%lx,%lx,%lx)\n", a0, a1, a2);

    INT rv = 0;
    __try {
        rv = Real_WSASetServiceW(a0, a1, a2);
    } __finally {
        _PrintExit("WSASetServiceW(,,) -> %lx\n", rv);
    };
    return rv;
}

SOCKET __stdcall Mine_WSASocketA(int a0,
                                 int a1,
                                 int a2,
                                 struct _WSAPROTOCOL_INFOA* a3,
                                 GROUP a4,
                                 DWORD a5)
{
    _PrintEnter("WSASocketA(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    SOCKET rv = 0;
    __try {
        rv = Real_WSASocketA(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("WSASocketA(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

SOCKET __stdcall Mine_WSASocketW(int a0,
                                 int a1,
                                 int a2,
                                 struct _WSAPROTOCOL_INFOW* a3,
                                 GROUP a4,
                                 DWORD a5)
{
    _PrintEnter("WSASocketW(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    SOCKET rv = 0;
    __try {
        rv = Real_WSASocketW(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("WSASocketW(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSAStartup(WORD a0,
                              LPWSADATA a1)
{
    _PrintEnter("WSAStartup(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_WSAStartup(a0, a1);
    } __finally {
        _PrintExit("WSAStartup(,) -> %lx\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAStringToAddressA(LPSTR a0,
                                       INT a1,
                                       struct _WSAPROTOCOL_INFOA* a2,
                                       LPSOCKADDR a3,
                                       LPINT a4)
{
    _PrintEnter("WSAStringToAddressA(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    INT rv = 0;
    __try {
        rv = Real_WSAStringToAddressA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WSAStringToAddressA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

INT __stdcall Mine_WSAStringToAddressW(LPWSTR a0,
                                       INT a1,
                                       struct _WSAPROTOCOL_INFOW* a2,
                                       LPSOCKADDR a3,
                                       LPINT a4)
{
    _PrintEnter("WSAStringToAddressW(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    INT rv = 0;
    __try {
        rv = Real_WSAStringToAddressW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WSAStringToAddressW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_WSAUnhookBlockingHook(void)
{
    _PrintEnter("WSAUnhookBlockingHook()\n");

    int rv = 0;
    __try {
        rv = Real_WSAUnhookBlockingHook();
    } __finally {
        _PrintExit("WSAUnhookBlockingHook() -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_WSAWaitForMultipleEvents(DWORD a0,
                                              void** a1,
                                              BOOL a2,
                                              DWORD a3,
                                              BOOL a4)
{
    _PrintEnter("WSAWaitForMultipleEvents(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_WSAWaitForMultipleEvents(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WSAWaitForMultipleEvents(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WaitCommEvent(HANDLE a0,
                                  LPDWORD a1,
                                  LPOVERLAPPED a2)
{
    _PrintEnter("WaitCommEvent(%lx,%lx,%lx)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_WaitCommEvent(a0, a1, a2);
    } __finally {
        _PrintExit("WaitCommEvent(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WaitForDebugEvent(struct _DEBUG_EVENT* a0,
                                      DWORD a1)
{
    _PrintEnter("WaitForDebugEvent(%lx,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_WaitForDebugEvent(a0, a1);
    } __finally {
        _PrintExit("WaitForDebugEvent(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_WaitForInputIdle(HANDLE a0,
                                      DWORD a1)
{
    _PrintEnter("WaitForInputIdle(%lx,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_WaitForInputIdle(a0, a1);
    } __finally {
        _PrintExit("WaitForInputIdle(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_WaitForMultipleObjects(DWORD a0,
                                            void** a1,
                                            BOOL a2,
                                            DWORD a3)
{
    _PrintEnter("WaitForMultipleObjects(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    DWORD rv = 0;
    __try {
        rv = Real_WaitForMultipleObjects(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WaitForMultipleObjects(,,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_WaitForMultipleObjectsEx(DWORD a0,
                                              void** a1,
                                              BOOL a2,
                                              DWORD a3,
                                              BOOL a4)
{
    _PrintEnter("WaitForMultipleObjectsEx(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    DWORD rv = 0;
    __try {
        rv = Real_WaitForMultipleObjectsEx(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WaitForMultipleObjectsEx(,,,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_WaitForSingleObject(HANDLE a0,
                                         DWORD a1)
{
    _PrintEnter("WaitForSingleObject(%lx,%lx)\n", a0, a1);

    DWORD rv = 0;
    __try {
        rv = Real_WaitForSingleObject(a0, a1);
    } __finally {
        _PrintExit("WaitForSingleObject(,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_WaitForSingleObjectEx(HANDLE a0,
                                           DWORD a1,
                                           BOOL a2)
{
    _PrintEnter("WaitForSingleObjectEx(%lx,%lx,%lx)\n", a0, a1, a2);

    DWORD rv = 0;
    __try {
        rv = Real_WaitForSingleObjectEx(a0, a1, a2);
    } __finally {
        _PrintExit("WaitForSingleObjectEx(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WaitMessage(void)
{
    _PrintEnter("WaitMessage()\n");

    BOOL rv = 0;
    __try {
        rv = Real_WaitMessage();
    } __finally {
        _PrintExit("WaitMessage() -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WaitNamedPipeA(LPCSTR a0,
                                   DWORD a1)
{
    _PrintEnter("WaitNamedPipeA(%hs,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_WaitNamedPipeA(a0, a1);
    } __finally {
        _PrintExit("WaitNamedPipeA(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WaitNamedPipeW(LPCWSTR a0,
                                   DWORD a1)
{
    _PrintEnter("WaitNamedPipeW(%ls,%lx)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_WaitNamedPipeW(a0, a1);
    } __finally {
        _PrintExit("WaitNamedPipeW(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WidenPath(HDC a0)
{
    _PrintEnter("WidenPath(%lx)\n", a0);

    BOOL rv = 0;
    __try {
        rv = Real_WidenPath(a0);
    } __finally {
        _PrintExit("WidenPath() -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine_WinExec(LPCSTR a0,
                            UINT a1)
{
    _PrintEnter("WinExec(%hs,%lx)\n", a0, a1);

    UINT rv = 0;
    __try {
        rv = Real_WinExec(a0, a1);
    } __finally {
        _PrintExit("WinExec(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WinHelpA(HWND a0,
                             LPCSTR a1,
                             UINT a2,
                             ULONG_PTR a3)
{
    _PrintEnter("WinHelpA(%lx,%hs,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_WinHelpA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WinHelpA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WinHelpW(HWND a0,
                             LPCWSTR a1,
                             UINT a2,
                             ULONG_PTR a3)
{
    _PrintEnter("WinHelpW(%lx,%ls,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_WinHelpW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WinHelpW(,,,) -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_WindowFromDC(HDC a0)
{
    _PrintEnter("WindowFromDC(%lx)\n", a0);

    HWND rv = 0;
    __try {
        rv = Real_WindowFromDC(a0);
    } __finally {
        _PrintExit("WindowFromDC() -> %lx\n", rv);
    };
    return rv;
}

HWND __stdcall Mine_WindowFromPoint(POINT a0)
{
    _PrintEnter("WindowFromPoint(%lx)\n", a0);

    HWND rv = 0;
    __try {
        rv = Real_WindowFromPoint(a0);
    } __finally {
        _PrintExit("WindowFromPoint() -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_WriteClassStg(struct IStorage* a0,
                                     IID& a1)
{
    _PrintEnter("WriteClassStg(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_WriteClassStg(a0, a1);
    } __finally {
        _PrintExit("WriteClassStg(,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_WriteClassStm(LPSTREAM a0,
                                     IID& a1)
{
    _PrintEnter("WriteClassStm(%lx,%lx)\n", a0, a1);

    HRESULT rv = 0;
    __try {
        rv = Real_WriteClassStm(a0, a1);
    } __finally {
        _PrintExit("WriteClassStm(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteConsoleA(HANDLE a0,
                                  void* a1,
                                  DWORD a2,
                                  LPDWORD a3,
                                  LPVOID a4)
{
    _PrintEnter("WriteConsoleA(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WriteConsoleA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WriteConsoleA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteConsoleInputA(HANDLE a0,
                                       INPUT_RECORD* a1,
                                       DWORD a2,
                                       LPDWORD a3)
{
    _PrintEnter("WriteConsoleInputA(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_WriteConsoleInputA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WriteConsoleInputA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteConsoleInputW(HANDLE a0,
                                       INPUT_RECORD* a1,
                                       DWORD a2,
                                       LPDWORD a3)
{
    _PrintEnter("WriteConsoleInputW(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_WriteConsoleInputW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WriteConsoleInputW(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteConsoleOutputA(HANDLE a0,
                                        CHAR_INFO* a1,
                                        COORD a2,
                                        COORD a3,
                                        PSMALL_RECT a4)
{
    _PrintEnter("WriteConsoleOutputA(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WriteConsoleOutputA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WriteConsoleOutputA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteConsoleOutputAttribute(HANDLE a0,
                                                WORD* a1,
                                                DWORD a2,
                                                COORD a3,
                                                LPDWORD a4)
{
    _PrintEnter("WriteConsoleOutputAttribute(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WriteConsoleOutputAttribute(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WriteConsoleOutputAttribute(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteConsoleOutputCharacterA(HANDLE a0,
                                                 LPCSTR a1,
                                                 DWORD a2,
                                                 COORD a3,
                                                 LPDWORD a4)
{
    _PrintEnter("WriteConsoleOutputCharacterA(%lx,%hs,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WriteConsoleOutputCharacterA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WriteConsoleOutputCharacterA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteConsoleOutputCharacterW(HANDLE a0,
                                                 LPCWSTR a1,
                                                 DWORD a2,
                                                 COORD a3,
                                                 LPDWORD a4)
{
    _PrintEnter("WriteConsoleOutputCharacterW(%lx,%ls,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WriteConsoleOutputCharacterW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WriteConsoleOutputCharacterW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteConsoleOutputW(HANDLE a0,
                                        CHAR_INFO* a1,
                                        COORD a2,
                                        COORD a3,
                                        PSMALL_RECT a4)
{
    _PrintEnter("WriteConsoleOutputW(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WriteConsoleOutputW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WriteConsoleOutputW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteConsoleW(HANDLE a0,
                                  void* a1,
                                  DWORD a2,
                                  LPDWORD a3,
                                  LPVOID a4)
{
    _PrintEnter("WriteConsoleW(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WriteConsoleW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WriteConsoleW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteFile(HANDLE a0,
                              LPCVOID a1,
                              DWORD a2,
                              LPDWORD a3,
                              LPOVERLAPPED a4)
{
    _PrintEnter("WriteFile(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WriteFile(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WriteFile(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteFileEx(HANDLE a0,
                                LPCVOID a1,
                                DWORD a2,
                                LPOVERLAPPED a3,
                                LPOVERLAPPED_COMPLETION_ROUTINE a4)
{
    _PrintEnter("WriteFileEx(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WriteFileEx(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WriteFileEx(,,,,) -> %lx\n", rv);
    };
    return rv;
}

HRESULT __stdcall Mine_WriteFmtUserTypeStg(struct IStorage* a0,
                                           CLIPFORMAT a1,
                                           LPOLESTR a2)
{
    _PrintEnter("WriteFmtUserTypeStg(%lx,%lx,%lx)\n", a0, a1, a2);

    HRESULT rv = 0;
    __try {
        rv = Real_WriteFmtUserTypeStg(a0, a1, a2);
    } __finally {
        _PrintExit("WriteFmtUserTypeStg(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WritePrivateProfileSectionA(LPCSTR a0,
                                                LPCSTR a1,
                                                LPCSTR a2)
{
    _PrintEnter("WritePrivateProfileSectionA(%hs,%hs,%hs)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_WritePrivateProfileSectionA(a0, a1, a2);
    } __finally {
        _PrintExit("WritePrivateProfileSectionA(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WritePrivateProfileSectionW(LPCWSTR a0,
                                                LPCWSTR a1,
                                                LPCWSTR a2)
{
    _PrintEnter("WritePrivateProfileSectionW(%ls,%ls,%ls)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_WritePrivateProfileSectionW(a0, a1, a2);
    } __finally {
        _PrintExit("WritePrivateProfileSectionW(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WritePrivateProfileStringA(LPCSTR a0,
                                               LPCSTR a1,
                                               LPCSTR a2,
                                               LPCSTR a3)
{
    _PrintEnter("WritePrivateProfileStringA(%hs,%hs,%hs,%hs)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_WritePrivateProfileStringA(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WritePrivateProfileStringA(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WritePrivateProfileStringW(LPCWSTR a0,
                                               LPCWSTR a1,
                                               LPCWSTR a2,
                                               LPCWSTR a3)
{
    _PrintEnter("WritePrivateProfileStringW(%ls,%ls,%ls,%ls)\n", a0, a1, a2, a3);

    BOOL rv = 0;
    __try {
        rv = Real_WritePrivateProfileStringW(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WritePrivateProfileStringW(,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WritePrivateProfileStructA(LPCSTR a0,
                                               LPCSTR a1,
                                               LPVOID a2,
                                               UINT a3,
                                               LPCSTR a4)
{
    _PrintEnter("WritePrivateProfileStructA(%hs,%hs,%lx,%lx,%hs)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WritePrivateProfileStructA(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WritePrivateProfileStructA(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WritePrivateProfileStructW(LPCWSTR a0,
                                               LPCWSTR a1,
                                               LPVOID a2,
                                               UINT a3,
                                               LPCWSTR a4)
{
    _PrintEnter("WritePrivateProfileStructW(%ls,%ls,%lx,%lx,%ls)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WritePrivateProfileStructW(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WritePrivateProfileStructW(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteProcessMemory(HANDLE a0,
                                       LPVOID a1,
                                       LPVOID a2,
                                       DWORD a3,
                                       LPDWORD a4)
{
    _PrintEnter("WriteProcessMemory(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    BOOL rv = 0;
    __try {
        rv = Real_WriteProcessMemory(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("WriteProcessMemory(,,,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteProfileSectionA(LPCSTR a0,
                                         LPCSTR a1)
{
    _PrintEnter("WriteProfileSectionA(%hs,%hs)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_WriteProfileSectionA(a0, a1);
    } __finally {
        _PrintExit("WriteProfileSectionA(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteProfileSectionW(LPCWSTR a0,
                                         LPCWSTR a1)
{
    _PrintEnter("WriteProfileSectionW(%ls,%ls)\n", a0, a1);

    BOOL rv = 0;
    __try {
        rv = Real_WriteProfileSectionW(a0, a1);
    } __finally {
        _PrintExit("WriteProfileSectionW(,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteProfileStringA(LPCSTR a0,
                                        LPCSTR a1,
                                        LPCSTR a2)
{
    _PrintEnter("WriteProfileStringA(%hs,%hs,%hs)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_WriteProfileStringA(a0, a1, a2);
    } __finally {
        _PrintExit("WriteProfileStringA(,,) -> %lx\n", rv);
    };
    return rv;
}

BOOL __stdcall Mine_WriteProfileStringW(LPCWSTR a0,
                                        LPCWSTR a1,
                                        LPCWSTR a2)
{
    _PrintEnter("WriteProfileStringW(%ls,%ls,%ls)\n", a0, a1, a2);

    BOOL rv = 0;
    __try {
        rv = Real_WriteProfileStringW(a0, a1, a2);
    } __finally {
        _PrintExit("WriteProfileStringW(,,) -> %lx\n", rv);
    };
    return rv;
}

DWORD __stdcall Mine_WriteTapemark(HANDLE a0,
                                   DWORD a1,
                                   DWORD a2,
                                   BOOL a3)
{
    _PrintEnter("WriteTapemark(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    DWORD rv = 0;
    __try {
        rv = Real_WriteTapemark(a0, a1, a2, a3);
    } __finally {
        _PrintExit("WriteTapemark(,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine___WSAFDIsSet(SOCKET a0,
                                fd_set* a1)
{
    _PrintEnter("__WSAFDIsSet(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real___WSAFDIsSet(a0, a1);
    } __finally {
        _PrintExit("__WSAFDIsSet(,) -> %lx\n", rv);
    };
    return rv;
}

long __stdcall Mine__hread(HFILE a0,
                           LPVOID a1,
                           long a2)
{
    _PrintEnter("_hread(%lx,%lx,%lx)\n", a0, a1, a2);

    long rv = 0;
    __try {
        rv = Real__hread(a0, a1, a2);
    } __finally {
        _PrintExit("_hread(,,) -> %lx\n", rv);
    };
    return rv;
}

long __stdcall Mine__hwrite(HFILE a0,
                            LPCSTR a1,
                            long a2)
{
    _PrintEnter("_hwrite(%lx,%hs,%lx)\n", a0, a1, a2);

    long rv = 0;
    __try {
        rv = Real__hwrite(a0, a1, a2);
    } __finally {
        _PrintExit("_hwrite(,,) -> %lx\n", rv);
    };
    return rv;
}

HFILE __stdcall Mine__lclose(HFILE a0)
{
    _PrintEnter("_lclose(%lx)\n", a0);

    HFILE rv = 0;
    __try {
        rv = Real__lclose(a0);
    } __finally {
        _PrintExit("_lclose() -> %lx\n", rv);
    };
    return rv;
}

HFILE __stdcall Mine__lcreat(LPCSTR a0,
                             int a1)
{
    _PrintEnter("_lcreat(%hs,%lx)\n", a0, a1);

    HFILE rv = 0;
    __try {
        rv = Real__lcreat(a0, a1);
    } __finally {
        _PrintExit("_lcreat(,) -> %lx\n", rv);
    };
    return rv;
}

LONG __stdcall Mine__llseek(HFILE a0,
                            LONG a1,
                            int a2)
{
    _PrintEnter("_llseek(%lx,%lx,%lx)\n", a0, a1, a2);

    LONG rv = 0;
    __try {
        rv = Real__llseek(a0, a1, a2);
    } __finally {
        _PrintExit("_llseek(,,) -> %lx\n", rv);
    };
    return rv;
}

HFILE __stdcall Mine__lopen(LPCSTR a0,
                            int a1)
{
    _PrintEnter("_lopen(%hs,%lx)\n", a0, a1);

    HFILE rv = 0;
    __try {
        rv = Real__lopen(a0, a1);
    } __finally {
        _PrintExit("_lopen(,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine__lread(HFILE a0,
                           LPVOID a1,
                           UINT a2)
{
    _PrintEnter("_lread(%lx,%lx,%lx)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real__lread(a0, a1, a2);
    } __finally {
        _PrintExit("_lread(,,) -> %lx\n", rv);
    };
    return rv;
}

UINT __stdcall Mine__lwrite(HFILE a0,
                            LPCSTR a1,
                            UINT a2)
{
    _PrintEnter("_lwrite(%lx,%hs,%lx)\n", a0, a1, a2);

    UINT rv = 0;
    __try {
        rv = Real__lwrite(a0, a1, a2);
    } __finally {
        _PrintExit("_lwrite(,,) -> %lx\n", rv);
    };
    return rv;
}

SOCKET __stdcall Mine_accept(SOCKET a0,
                             sockaddr* a1,
                             int* a2)
{
    _PrintEnter("accept(%lx,%lx,%lx)\n", a0, a1, a2);

    SOCKET rv = 0;
    __try {
        rv = Real_accept(a0, a1, a2);
    } __finally {
        _PrintExit("accept(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_bind(SOCKET a0,
                        sockaddr* a1,
                        int a2)
{
    _PrintEnter("bind(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_bind(a0, a1, a2);
    } __finally {
        _PrintExit("bind(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_closesocket(SOCKET a0)
{
    _PrintEnter("closesocket(%lx)\n", a0);

    int rv = 0;
    __try {
        rv = Real_closesocket(a0);
    } __finally {
        _PrintExit("closesocket() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_connect(SOCKET a0,
                           sockaddr* a1,
                           int a2)
{
    _PrintEnter("connect(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_connect(a0, a1, a2);
    } __finally {
        _PrintExit("connect(,,) -> %lx\n", rv);
    };
    return rv;
}

hostent* __stdcall Mine_gethostbyaddr(char* a0,
                                      int a1,
                                      int a2)
{
    _PrintEnter("gethostbyaddr(%lx,%lx,%lx)\n", a0, a1, a2);

    hostent* rv = 0;
    __try {
        rv = Real_gethostbyaddr(a0, a1, a2);
    } __finally {
        _PrintExit("gethostbyaddr(,,) -> %lx\n", rv);
    };
    return rv;
}

hostent* __stdcall Mine_gethostbyname(char* a0)
{
    _PrintEnter("gethostbyname(%lx)\n", a0);

    hostent* rv = 0;
    __try {
        rv = Real_gethostbyname(a0);
    } __finally {
        _PrintExit("gethostbyname() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_gethostname(char* a0,
                               int a1)
{
    _PrintEnter("gethostname(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_gethostname(a0, a1);
    } __finally {
        _PrintExit("gethostname(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_getpeername(SOCKET a0,
                               sockaddr* a1,
                               int* a2)
{
    _PrintEnter("getpeername(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_getpeername(a0, a1, a2);
    } __finally {
        _PrintExit("getpeername(,,) -> %lx\n", rv);
    };
    return rv;
}

protoent* __stdcall Mine_getprotobyname(char* a0)
{
    _PrintEnter("getprotobyname(%lx)\n", a0);

    protoent* rv = 0;
    __try {
        rv = Real_getprotobyname(a0);
    } __finally {
        _PrintExit("getprotobyname() -> %lx\n", rv);
    };
    return rv;
}

protoent* __stdcall Mine_getprotobynumber(int a0)
{
    _PrintEnter("getprotobynumber(%lx)\n", a0);

    protoent* rv = 0;
    __try {
        rv = Real_getprotobynumber(a0);
    } __finally {
        _PrintExit("getprotobynumber() -> %lx\n", rv);
    };
    return rv;
}

servent* __stdcall Mine_getservbyname(char* a0,
                                      char* a1)
{
    _PrintEnter("getservbyname(%lx,%lx)\n", a0, a1);

    servent* rv = 0;
    __try {
        rv = Real_getservbyname(a0, a1);
    } __finally {
        _PrintExit("getservbyname(,) -> %lx\n", rv);
    };
    return rv;
}

servent* __stdcall Mine_getservbyport(int a0,
                                      char* a1)
{
    _PrintEnter("getservbyport(%lx,%lx)\n", a0, a1);

    servent* rv = 0;
    __try {
        rv = Real_getservbyport(a0, a1);
    } __finally {
        _PrintExit("getservbyport(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_getsockname(SOCKET a0,
                               sockaddr* a1,
                               int* a2)
{
    _PrintEnter("getsockname(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_getsockname(a0, a1, a2);
    } __finally {
        _PrintExit("getsockname(,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_getsockopt(SOCKET a0,
                              int a1,
                              int a2,
                              char* a3,
                              int* a4)
{
    _PrintEnter("getsockopt(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_getsockopt(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("getsockopt(,,,,) -> %lx\n", rv);
    };
    return rv;
}

u_long __stdcall Mine_htonl(u_long a0)
{
    _PrintEnter("htonl(%lx)\n", a0);

    u_long rv = 0;
    __try {
        rv = Real_htonl(a0);
    } __finally {
        _PrintExit("htonl() -> %lx\n", rv);
    };
    return rv;
}

u_short __stdcall Mine_htons(u_short a0)
{
    _PrintEnter("htons(%lx)\n", a0);

    u_short rv = 0;
    __try {
        rv = Real_htons(a0);
    } __finally {
        _PrintExit("htons() -> %lx\n", rv);
    };
    return rv;
}

unsigned long __stdcall Mine_inet_addr(char* a0)
{
    _PrintEnter("inet_addr(%lx)\n", a0);

    unsigned long rv = 0;
    __try {
        rv = Real_inet_addr(a0);
    } __finally {
        _PrintExit("inet_addr() -> %lx\n", rv);
    };
    return rv;
}

char* __stdcall Mine_inet_ntoa(in_addr a0)
{
    _PrintEnter("inet_ntoa(%lx)\n", a0);

    char* rv = 0;
    __try {
        rv = Real_inet_ntoa(a0);
    } __finally {
        _PrintExit("inet_ntoa() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_ioctlsocket(SOCKET a0,
                               long a1,
                               u_long* a2)
{
    _PrintEnter("ioctlsocket(%lx,%lx,%lx)\n", a0, a1, a2);

    int rv = 0;
    __try {
        rv = Real_ioctlsocket(a0, a1, a2);
    } __finally {
        _PrintExit("ioctlsocket(,,) -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_keybd_event(BYTE a0,
                                BYTE a1,
                                DWORD a2,
                                ULONG_PTR a3)
{
    _PrintEnter("keybd_event(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    __try {
        Real_keybd_event(a0, a1, a2, a3);
    } __finally {
        _PrintExit("keybd_event(,,,) ->\n");
    };
}

int __stdcall Mine_listen(SOCKET a0,
                          int a1)
{
    _PrintEnter("listen(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_listen(a0, a1);
    } __finally {
        _PrintExit("listen(,) -> %lx\n", rv);
    };
    return rv;
}

LPSTR __stdcall Mine_lstrcatA(LPSTR a0,
                              LPCSTR a1)
{
    _PrintEnter("lstrcatA(%hs,%hs)\n", a0, a1);

    LPSTR rv = 0;
    __try {
        rv = Real_lstrcatA(a0, a1);
    } __finally {
        _PrintExit("lstrcatA(%hs,) -> %hs\n", a0, rv);
    };
    return rv;
}

LPWSTR __stdcall Mine_lstrcatW(LPWSTR a0,
                               LPCWSTR a1)
{
    _PrintEnter("lstrcatW(%ls,%ls)\n", a0, a1);

    LPWSTR rv = 0;
    __try {
        rv = Real_lstrcatW(a0, a1);
    } __finally {
        _PrintExit("lstrcatW(%ls,) -> %ls\n", a0, rv);
    };
    return rv;
}

int __stdcall Mine_lstrcmpA(LPCSTR a0,
                            LPCSTR a1)
{
    _PrintEnter("lstrcmpA(%hs,%hs)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_lstrcmpA(a0, a1);
    } __finally {
        _PrintExit("lstrcmpA(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_lstrcmpW(LPCWSTR a0,
                            LPCWSTR a1)
{
    _PrintEnter("lstrcmpW(%ls,%ls)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_lstrcmpW(a0, a1);
    } __finally {
        _PrintExit("lstrcmpW(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_lstrcmpiA(LPCSTR a0,
                             LPCSTR a1)
{
    _PrintEnter("lstrcmpiA(%hs,%hs)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_lstrcmpiA(a0, a1);
    } __finally {
        _PrintExit("lstrcmpiA(,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_lstrcmpiW(LPCWSTR a0,
                             LPCWSTR a1)
{
    _PrintEnter("lstrcmpiW(%ls,%ls)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_lstrcmpiW(a0, a1);
    } __finally {
        _PrintExit("lstrcmpiW(,) -> %lx\n", rv);
    };
    return rv;
}

LPSTR __stdcall Mine_lstrcpyA(LPSTR a0,
                              LPCSTR a1)
{
    _PrintEnter("lstrcpyA(%lx,%hs)\n", a0, a1);

    LPSTR rv = 0;
    __try {
        rv = Real_lstrcpyA(a0, a1);
    } __finally {
        _PrintExit("lstrcpyA(%hs,) -> %hs\n", a0, rv);
    };
    return rv;
}

LPWSTR __stdcall Mine_lstrcpyW(LPWSTR a0,
                               LPCWSTR a1)
{
    _PrintEnter("lstrcpyW(%lx,%ls)\n", a0, a1);

    LPWSTR rv = 0;
    __try {
        rv = Real_lstrcpyW(a0, a1);
    } __finally {
        _PrintExit("lstrcpyW(%ls,) -> %ls\n", a0, rv);
    };
    return rv;
}

LPSTR __stdcall Mine_lstrcpynA(LPSTR a0,
                               LPCSTR a1,
                               int a2)
{
    _PrintEnter("lstrcpynA(%lx,%hs,%lx)\n", a0, a1, a2);

    LPSTR rv = 0;
    __try {
        rv = Real_lstrcpynA(a0, a1, a2);
    } __finally {
        _PrintExit("lstrcpynA(%hs,,) -> %hs\n", a0, rv);
    };
    return rv;
}

LPWSTR __stdcall Mine_lstrcpynW(LPWSTR a0,
                                LPCWSTR a1,
                                int a2)
{
    _PrintEnter("lstrcpynW(%lx,%ls,%lx)\n", a0, a1, a2);

    LPWSTR rv = 0;
    __try {
        rv = Real_lstrcpynW(a0, a1, a2);
    } __finally {
        _PrintExit("lstrcpynW(%ls,,) -> %ls\n", a0, rv);
    };
    return rv;
}

int __stdcall Mine_lstrlenA(LPCSTR a0)
{
    _PrintEnter("lstrlenA(%hs)\n", a0);

    int rv = 0;
    __try {
        rv = Real_lstrlenA(a0);
    } __finally {
        _PrintExit("lstrlenA() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_lstrlenW(LPCWSTR a0)
{
    _PrintEnter("lstrlenW(%ls)\n", a0);

    int rv = 0;
    __try {
        rv = Real_lstrlenW(a0);
    } __finally {
        _PrintExit("lstrlenW() -> %lx\n", rv);
    };
    return rv;
}

void __stdcall Mine_mouse_event(DWORD a0,
                                DWORD a1,
                                DWORD a2,
                                DWORD a3,
                                ULONG_PTR a4)
{
    _PrintEnter("mouse_event(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    __try {
        Real_mouse_event(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("mouse_event(,,,,) ->\n");
    };
}

u_long __stdcall Mine_ntohl(u_long a0)
{
    _PrintEnter("ntohl(%lx)\n", a0);

    u_long rv = 0;
    __try {
        rv = Real_ntohl(a0);
    } __finally {
        _PrintExit("ntohl() -> %lx\n", rv);
    };
    return rv;
}

u_short __stdcall Mine_ntohs(u_short a0)
{
    _PrintEnter("ntohs(%lx)\n", a0);

    u_short rv = 0;
    __try {
        rv = Real_ntohs(a0);
    } __finally {
        _PrintExit("ntohs() -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_recv(SOCKET a0,
                        char* a1,
                        int a2,
                        int a3)
{
    _PrintEnter("recv(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_recv(a0, a1, a2, a3);
    } __finally {
        _PrintExit("recv(,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_recvfrom(SOCKET a0,
                            char* a1,
                            int a2,
                            int a3,
                            sockaddr* a4,
                            int* a5)
{
    _PrintEnter("recvfrom(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_recvfrom(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("recvfrom(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_select(int a0,
                          fd_set* a1,
                          fd_set* a2,
                          fd_set* a3,
                          timeval* a4)
{
    _PrintEnter("select(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_select(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("select(,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_send(SOCKET a0,
                        char* a1,
                        int a2,
                        int a3)
{
    _PrintEnter("send(%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3);

    int rv = 0;
    __try {
        rv = Real_send(a0, a1, a2, a3);
    } __finally {
        _PrintExit("send(,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_sendto(SOCKET a0,
                          char* a1,
                          int a2,
                          int a3,
                          sockaddr* a4,
                          int a5)
{
    _PrintEnter("sendto(%lx,%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4, a5);

    int rv = 0;
    __try {
        rv = Real_sendto(a0, a1, a2, a3, a4, a5);
    } __finally {
        _PrintExit("sendto(,,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_setsockopt(SOCKET a0,
                              int a1,
                              int a2,
                              char* a3,
                              int a4)
{
    _PrintEnter("setsockopt(%lx,%lx,%lx,%lx,%lx)\n", a0, a1, a2, a3, a4);

    int rv = 0;
    __try {
        rv = Real_setsockopt(a0, a1, a2, a3, a4);
    } __finally {
        _PrintExit("setsockopt(,,,,) -> %lx\n", rv);
    };
    return rv;
}

int __stdcall Mine_shutdown(SOCKET a0,
                            int a1)
{
    _PrintEnter("shutdown(%lx,%lx)\n", a0, a1);

    int rv = 0;
    __try {
        rv = Real_shutdown(a0, a1);
    } __finally {
        _PrintExit("shutdown(,) -> %lx\n", rv);
    };
    return rv;
}

SOCKET __stdcall Mine_socket(int a0,
                             int a1,
                             int a2)
{
    _PrintEnter("socket(%lx,%lx,%lx)\n", a0, a1, a2);

    SOCKET rv = 0;
    __try {
        rv = Real_socket(a0, a1, a2);
    } __finally {
        _PrintExit("socket(,,) -> %lx\n", rv);
    };
    return rv;
}

////////////////////////////////////////////////////////////// TrampolineWith.
//
VOID TrampolineWith(VOID)
{
    DetourFunctionWithTrampoline((PBYTE)Real_AbortDoc,
                                 (PBYTE)Mine_AbortDoc);
    DetourFunctionWithTrampoline((PBYTE)Real_AbortPath,
                                 (PBYTE)Mine_AbortPath);
    DetourFunctionWithTrampoline((PBYTE)Real_ActivateKeyboardLayout,
                                 (PBYTE)Mine_ActivateKeyboardLayout);
    DetourFunctionWithTrampoline((PBYTE)Real_AddAtomA,
                                 (PBYTE)Mine_AddAtomA);
    DetourFunctionWithTrampoline((PBYTE)Real_AddAtomW,
                                 (PBYTE)Mine_AddAtomW);
    DetourFunctionWithTrampoline((PBYTE)Real_AddFontResourceA,
                                 (PBYTE)Mine_AddFontResourceA);
    DetourFunctionWithTrampoline((PBYTE)Real_AddFontResourceW,
                                 (PBYTE)Mine_AddFontResourceW);
    DetourFunctionWithTrampoline((PBYTE)Real_AdjustWindowRect,
                                 (PBYTE)Mine_AdjustWindowRect);
    DetourFunctionWithTrampoline((PBYTE)Real_AdjustWindowRectEx,
                                 (PBYTE)Mine_AdjustWindowRectEx);
    DetourFunctionWithTrampoline((PBYTE)Real_AllocConsole,
                                 (PBYTE)Mine_AllocConsole);
    DetourFunctionWithTrampoline((PBYTE)Real_AngleArc,
                                 (PBYTE)Mine_AngleArc);
    DetourFunctionWithTrampoline((PBYTE)Real_AnimatePalette,
                                 (PBYTE)Mine_AnimatePalette);
    DetourFunctionWithTrampoline((PBYTE)Real_AnyPopup,
                                 (PBYTE)Mine_AnyPopup);
    DetourFunctionWithTrampoline((PBYTE)Real_AppendMenuA,
                                 (PBYTE)Mine_AppendMenuA);
    DetourFunctionWithTrampoline((PBYTE)Real_AppendMenuW,
                                 (PBYTE)Mine_AppendMenuW);
    DetourFunctionWithTrampoline((PBYTE)Real_Arc,
                                 (PBYTE)Mine_Arc);
    DetourFunctionWithTrampoline((PBYTE)Real_ArcTo,
                                 (PBYTE)Mine_ArcTo);
    DetourFunctionWithTrampoline((PBYTE)Real_AreFileApisANSI,
                                 (PBYTE)Mine_AreFileApisANSI);
    DetourFunctionWithTrampoline((PBYTE)Real_ArrangeIconicWindows,
                                 (PBYTE)Mine_ArrangeIconicWindows);
    DetourFunctionWithTrampoline((PBYTE)Real_AttachThreadInput,
                                 (PBYTE)Mine_AttachThreadInput);
    DetourFunctionWithTrampoline((PBYTE)Real_BackupRead,
                                 (PBYTE)Mine_BackupRead);
    DetourFunctionWithTrampoline((PBYTE)Real_BackupSeek,
                                 (PBYTE)Mine_BackupSeek);
    DetourFunctionWithTrampoline((PBYTE)Real_BackupWrite,
                                 (PBYTE)Mine_BackupWrite);
    DetourFunctionWithTrampoline((PBYTE)Real_Beep,
                                 (PBYTE)Mine_Beep);
    DetourFunctionWithTrampoline((PBYTE)Real_BeginDeferWindowPos,
                                 (PBYTE)Mine_BeginDeferWindowPos);
    DetourFunctionWithTrampoline((PBYTE)Real_BeginPaint,
                                 (PBYTE)Mine_BeginPaint);
    DetourFunctionWithTrampoline((PBYTE)Real_BeginPath,
                                 (PBYTE)Mine_BeginPath);
    DetourFunctionWithTrampoline((PBYTE)Real_BeginUpdateResourceA,
                                 (PBYTE)Mine_BeginUpdateResourceA);
    DetourFunctionWithTrampoline((PBYTE)Real_BeginUpdateResourceW,
                                 (PBYTE)Mine_BeginUpdateResourceW);
    DetourFunctionWithTrampoline((PBYTE)Real_BindMoniker,
                                 (PBYTE)Mine_BindMoniker);
    DetourFunctionWithTrampoline((PBYTE)Real_BitBlt,
                                 (PBYTE)Mine_BitBlt);
    DetourFunctionWithTrampoline((PBYTE)Real_BringWindowToTop,
                                 (PBYTE)Mine_BringWindowToTop);
    DetourFunctionWithTrampoline((PBYTE)Real_BroadcastSystemMessageA,
                                 (PBYTE)Mine_BroadcastSystemMessageA);
    DetourFunctionWithTrampoline((PBYTE)Real_BroadcastSystemMessageW,
                                 (PBYTE)Mine_BroadcastSystemMessageW);
    DetourFunctionWithTrampoline((PBYTE)Real_BuildCommDCBA,
                                 (PBYTE)Mine_BuildCommDCBA);
    DetourFunctionWithTrampoline((PBYTE)Real_BuildCommDCBAndTimeoutsA,
                                 (PBYTE)Mine_BuildCommDCBAndTimeoutsA);
    DetourFunctionWithTrampoline((PBYTE)Real_BuildCommDCBAndTimeoutsW,
                                 (PBYTE)Mine_BuildCommDCBAndTimeoutsW);
    DetourFunctionWithTrampoline((PBYTE)Real_BuildCommDCBW,
                                 (PBYTE)Mine_BuildCommDCBW);
    DetourFunctionWithTrampoline((PBYTE)Real_CLSIDFromProgID,
                                 (PBYTE)Mine_CLSIDFromProgID);
    DetourFunctionWithTrampoline((PBYTE)Real_CLSIDFromString,
                                 (PBYTE)Mine_CLSIDFromString);
    DetourFunctionWithTrampoline((PBYTE)Real_CallMsgFilterA,
                                 (PBYTE)Mine_CallMsgFilterA);
    DetourFunctionWithTrampoline((PBYTE)Real_CallMsgFilterW,
                                 (PBYTE)Mine_CallMsgFilterW);
    DetourFunctionWithTrampoline((PBYTE)Real_CallNamedPipeA,
                                 (PBYTE)Mine_CallNamedPipeA);
    DetourFunctionWithTrampoline((PBYTE)Real_CallNamedPipeW,
                                 (PBYTE)Mine_CallNamedPipeW);
    DetourFunctionWithTrampoline((PBYTE)Real_CallNextHookEx,
                                 (PBYTE)Mine_CallNextHookEx);
    DetourFunctionWithTrampoline((PBYTE)Real_CallWindowProcA,
                                 (PBYTE)Mine_CallWindowProcA);
    DetourFunctionWithTrampoline((PBYTE)Real_CallWindowProcW,
                                 (PBYTE)Mine_CallWindowProcW);
    DetourFunctionWithTrampoline((PBYTE)Real_CancelDC,
                                 (PBYTE)Mine_CancelDC);
    DetourFunctionWithTrampoline((PBYTE)Real_CancelIo,
                                 (PBYTE)Mine_CancelIo);
    DetourFunctionWithTrampoline((PBYTE)Real_CancelWaitableTimer,
                                 (PBYTE)Mine_CancelWaitableTimer);
    DetourFunctionWithTrampoline((PBYTE)Real_CascadeWindows,
                                 (PBYTE)Mine_CascadeWindows);
    DetourFunctionWithTrampoline((PBYTE)Real_ChangeClipboardChain,
                                 (PBYTE)Mine_ChangeClipboardChain);
    DetourFunctionWithTrampoline((PBYTE)Real_ChangeDisplaySettingsA,
                                 (PBYTE)Mine_ChangeDisplaySettingsA);
    DetourFunctionWithTrampoline((PBYTE)Real_ChangeDisplaySettingsExA,
                                 (PBYTE)Mine_ChangeDisplaySettingsExA);
    DetourFunctionWithTrampoline((PBYTE)Real_ChangeDisplaySettingsExW,
                                 (PBYTE)Mine_ChangeDisplaySettingsExW);
    DetourFunctionWithTrampoline((PBYTE)Real_ChangeDisplaySettingsW,
                                 (PBYTE)Mine_ChangeDisplaySettingsW);
    DetourFunctionWithTrampoline((PBYTE)Real_ChangeMenuA,
                                 (PBYTE)Mine_ChangeMenuA);
    DetourFunctionWithTrampoline((PBYTE)Real_ChangeMenuW,
                                 (PBYTE)Mine_ChangeMenuW);
    DetourFunctionWithTrampoline((PBYTE)Real_CharLowerA,
                                 (PBYTE)Mine_CharLowerA);
    DetourFunctionWithTrampoline((PBYTE)Real_CharLowerBuffA,
                                 (PBYTE)Mine_CharLowerBuffA);
    DetourFunctionWithTrampoline((PBYTE)Real_CharLowerBuffW,
                                 (PBYTE)Mine_CharLowerBuffW);
    DetourFunctionWithTrampoline((PBYTE)Real_CharLowerW,
                                 (PBYTE)Mine_CharLowerW);
    DetourFunctionWithTrampoline((PBYTE)Real_CharNextA,
                                 (PBYTE)Mine_CharNextA);
    DetourFunctionWithTrampoline((PBYTE)Real_CharNextExA,
                                 (PBYTE)Mine_CharNextExA);
    DetourFunctionWithTrampoline((PBYTE)Real_CharNextW,
                                 (PBYTE)Mine_CharNextW);
    DetourFunctionWithTrampoline((PBYTE)Real_CharPrevA,
                                 (PBYTE)Mine_CharPrevA);
    DetourFunctionWithTrampoline((PBYTE)Real_CharPrevExA,
                                 (PBYTE)Mine_CharPrevExA);
    DetourFunctionWithTrampoline((PBYTE)Real_CharPrevW,
                                 (PBYTE)Mine_CharPrevW);
    DetourFunctionWithTrampoline((PBYTE)Real_CharToOemA,
                                 (PBYTE)Mine_CharToOemA);
    DetourFunctionWithTrampoline((PBYTE)Real_CharToOemBuffA,
                                 (PBYTE)Mine_CharToOemBuffA);
    DetourFunctionWithTrampoline((PBYTE)Real_CharToOemBuffW,
                                 (PBYTE)Mine_CharToOemBuffW);
    DetourFunctionWithTrampoline((PBYTE)Real_CharToOemW,
                                 (PBYTE)Mine_CharToOemW);
    DetourFunctionWithTrampoline((PBYTE)Real_CharUpperA,
                                 (PBYTE)Mine_CharUpperA);
    DetourFunctionWithTrampoline((PBYTE)Real_CharUpperBuffA,
                                 (PBYTE)Mine_CharUpperBuffA);
    DetourFunctionWithTrampoline((PBYTE)Real_CharUpperBuffW,
                                 (PBYTE)Mine_CharUpperBuffW);
    DetourFunctionWithTrampoline((PBYTE)Real_CharUpperW,
                                 (PBYTE)Mine_CharUpperW);
    DetourFunctionWithTrampoline((PBYTE)Real_CheckColorsInGamut,
                                 (PBYTE)Mine_CheckColorsInGamut);
    DetourFunctionWithTrampoline((PBYTE)Real_CheckDlgButton,
                                 (PBYTE)Mine_CheckDlgButton);
    DetourFunctionWithTrampoline((PBYTE)Real_CheckMenuItem,
                                 (PBYTE)Mine_CheckMenuItem);
    DetourFunctionWithTrampoline((PBYTE)Real_CheckMenuRadioItem,
                                 (PBYTE)Mine_CheckMenuRadioItem);
    DetourFunctionWithTrampoline((PBYTE)Real_CheckRadioButton,
                                 (PBYTE)Mine_CheckRadioButton);
    DetourFunctionWithTrampoline((PBYTE)Real_ChildWindowFromPoint,
                                 (PBYTE)Mine_ChildWindowFromPoint);
    DetourFunctionWithTrampoline((PBYTE)Real_ChildWindowFromPointEx,
                                 (PBYTE)Mine_ChildWindowFromPointEx);
    DetourFunctionWithTrampoline((PBYTE)Real_ChoosePixelFormat,
                                 (PBYTE)Mine_ChoosePixelFormat);
    DetourFunctionWithTrampoline((PBYTE)Real_Chord,
                                 (PBYTE)Mine_Chord);
    DetourFunctionWithTrampoline((PBYTE)Real_ClearCommBreak,
                                 (PBYTE)Mine_ClearCommBreak);
    DetourFunctionWithTrampoline((PBYTE)Real_ClearCommError,
                                 (PBYTE)Mine_ClearCommError);
    DetourFunctionWithTrampoline((PBYTE)Real_ClientToScreen,
                                 (PBYTE)Mine_ClientToScreen);
    DetourFunctionWithTrampoline((PBYTE)Real_ClipCursor,
                                 (PBYTE)Mine_ClipCursor);
    DetourFunctionWithTrampoline((PBYTE)Real_CloseClipboard,
                                 (PBYTE)Mine_CloseClipboard);
    DetourFunctionWithTrampoline((PBYTE)Real_CloseDesktop,
                                 (PBYTE)Mine_CloseDesktop);
    DetourFunctionWithTrampoline((PBYTE)Real_CloseEnhMetaFile,
                                 (PBYTE)Mine_CloseEnhMetaFile);
    DetourFunctionWithTrampoline((PBYTE)Real_CloseFigure,
                                 (PBYTE)Mine_CloseFigure);
    DetourFunctionWithTrampoline((PBYTE)Real_CloseHandle,
                                 (PBYTE)Mine_CloseHandle);
    DetourFunctionWithTrampoline((PBYTE)Real_CloseMetaFile,
                                 (PBYTE)Mine_CloseMetaFile);
    DetourFunctionWithTrampoline((PBYTE)Real_CloseWindow,
                                 (PBYTE)Mine_CloseWindow);
    DetourFunctionWithTrampoline((PBYTE)Real_CloseWindowStation,
                                 (PBYTE)Mine_CloseWindowStation);
    DetourFunctionWithTrampoline((PBYTE)Real_CoAddRefServerProcess,
                                 (PBYTE)Mine_CoAddRefServerProcess);
    DetourFunctionWithTrampoline((PBYTE)Real_CoBuildVersion,
                                 (PBYTE)Mine_CoBuildVersion);
    DetourFunctionWithTrampoline((PBYTE)Real_CoCopyProxy,
                                 (PBYTE)Mine_CoCopyProxy);
    DetourFunctionWithTrampoline((PBYTE)Real_CoCreateFreeThreadedMarshaler,
                                 (PBYTE)Mine_CoCreateFreeThreadedMarshaler);
    DetourFunctionWithTrampoline((PBYTE)Real_CoCreateGuid,
                                 (PBYTE)Mine_CoCreateGuid);
    DetourFunctionWithTrampoline((PBYTE)Real_CoCreateInstance,
                                 (PBYTE)Mine_CoCreateInstance);
    DetourFunctionWithTrampoline((PBYTE)Real_CoCreateInstanceEx,
                                 (PBYTE)Mine_CoCreateInstanceEx);
    DetourFunctionWithTrampoline((PBYTE)Real_CoDisconnectObject,
                                 (PBYTE)Mine_CoDisconnectObject);
    DetourFunctionWithTrampoline((PBYTE)Real_CoDosDateTimeToFileTime,
                                 (PBYTE)Mine_CoDosDateTimeToFileTime);
    DetourFunctionWithTrampoline((PBYTE)Real_CoFileTimeNow,
                                 (PBYTE)Mine_CoFileTimeNow);
    DetourFunctionWithTrampoline((PBYTE)Real_CoFileTimeToDosDateTime,
                                 (PBYTE)Mine_CoFileTimeToDosDateTime);
    DetourFunctionWithTrampoline((PBYTE)Real_CoFreeAllLibraries,
                                 (PBYTE)Mine_CoFreeAllLibraries);
    DetourFunctionWithTrampoline((PBYTE)Real_CoFreeLibrary,
                                 (PBYTE)Mine_CoFreeLibrary);
    DetourFunctionWithTrampoline((PBYTE)Real_CoFreeUnusedLibraries,
                                 (PBYTE)Mine_CoFreeUnusedLibraries);
    DetourFunctionWithTrampoline((PBYTE)Real_CoGetCallContext,
                                 (PBYTE)Mine_CoGetCallContext);
    DetourFunctionWithTrampoline((PBYTE)Real_CoGetClassObject,
                                 (PBYTE)Mine_CoGetClassObject);
    DetourFunctionWithTrampoline((PBYTE)Real_CoGetCurrentProcess,
                                 (PBYTE)Mine_CoGetCurrentProcess);
    DetourFunctionWithTrampoline((PBYTE)Real_CoGetInstanceFromFile,
                                 (PBYTE)Mine_CoGetInstanceFromFile);
    DetourFunctionWithTrampoline((PBYTE)Real_CoGetInstanceFromIStorage,
                                 (PBYTE)Mine_CoGetInstanceFromIStorage);
    DetourFunctionWithTrampoline((PBYTE)Real_CoGetInterfaceAndReleaseStream,
                                 (PBYTE)Mine_CoGetInterfaceAndReleaseStream);
    DetourFunctionWithTrampoline((PBYTE)Real_CoGetMalloc,
                                 (PBYTE)Mine_CoGetMalloc);
    DetourFunctionWithTrampoline((PBYTE)Real_CoGetMarshalSizeMax,
                                 (PBYTE)Mine_CoGetMarshalSizeMax);
    DetourFunctionWithTrampoline((PBYTE)Real_CoGetObject,
                                 (PBYTE)Mine_CoGetObject);
    DetourFunctionWithTrampoline((PBYTE)Real_CoGetPSClsid,
                                 (PBYTE)Mine_CoGetPSClsid);
    DetourFunctionWithTrampoline((PBYTE)Real_CoGetStandardMarshal,
                                 (PBYTE)Mine_CoGetStandardMarshal);
    DetourFunctionWithTrampoline((PBYTE)Real_CoGetStdMarshalEx,
                                 (PBYTE)Mine_CoGetStdMarshalEx);
    DetourFunctionWithTrampoline((PBYTE)Real_CoGetTreatAsClass,
                                 (PBYTE)Mine_CoGetTreatAsClass);
    DetourFunctionWithTrampoline((PBYTE)Real_CoImpersonateClient,
                                 (PBYTE)Mine_CoImpersonateClient);
    DetourFunctionWithTrampoline((PBYTE)Real_CoInitialize,
                                 (PBYTE)Mine_CoInitialize);
    DetourFunctionWithTrampoline((PBYTE)Real_CoInitializeEx,
                                 (PBYTE)Mine_CoInitializeEx);
    DetourFunctionWithTrampoline((PBYTE)Real_CoInitializeSecurity,
                                 (PBYTE)Mine_CoInitializeSecurity);
    DetourFunctionWithTrampoline((PBYTE)Real_CoInstall,
                                 (PBYTE)Mine_CoInstall);
    DetourFunctionWithTrampoline((PBYTE)Real_CoIsHandlerConnected,
                                 (PBYTE)Mine_CoIsHandlerConnected);
    DetourFunctionWithTrampoline((PBYTE)Real_CoIsOle1Class,
                                 (PBYTE)Mine_CoIsOle1Class);
    DetourFunctionWithTrampoline((PBYTE)Real_CoLoadLibrary,
                                 (PBYTE)Mine_CoLoadLibrary);
    DetourFunctionWithTrampoline((PBYTE)Real_CoLockObjectExternal,
                                 (PBYTE)Mine_CoLockObjectExternal);
    DetourFunctionWithTrampoline((PBYTE)Real_CoMarshalHresult,
                                 (PBYTE)Mine_CoMarshalHresult);
    DetourFunctionWithTrampoline((PBYTE)Real_CoMarshalInterThreadInterfaceInStream,
                                 (PBYTE)Mine_CoMarshalInterThreadInterfaceInStream);
    DetourFunctionWithTrampoline((PBYTE)Real_CoMarshalInterface,
                                 (PBYTE)Mine_CoMarshalInterface);
    DetourFunctionWithTrampoline((PBYTE)Real_CoQueryAuthenticationServices,
                                 (PBYTE)Mine_CoQueryAuthenticationServices);
    DetourFunctionWithTrampoline((PBYTE)Real_CoQueryClientBlanket,
                                 (PBYTE)Mine_CoQueryClientBlanket);
    DetourFunctionWithTrampoline((PBYTE)Real_CoQueryProxyBlanket,
                                 (PBYTE)Mine_CoQueryProxyBlanket);
    DetourFunctionWithTrampoline((PBYTE)Real_CoRegisterChannelHook,
                                 (PBYTE)Mine_CoRegisterChannelHook);
    DetourFunctionWithTrampoline((PBYTE)Real_CoRegisterClassObject,
                                 (PBYTE)Mine_CoRegisterClassObject);
    DetourFunctionWithTrampoline((PBYTE)Real_CoRegisterMallocSpy,
                                 (PBYTE)Mine_CoRegisterMallocSpy);
    DetourFunctionWithTrampoline((PBYTE)Real_CoRegisterMessageFilter,
                                 (PBYTE)Mine_CoRegisterMessageFilter);
    DetourFunctionWithTrampoline((PBYTE)Real_CoRegisterPSClsid,
                                 (PBYTE)Mine_CoRegisterPSClsid);
    DetourFunctionWithTrampoline((PBYTE)Real_CoRegisterSurrogate,
                                 (PBYTE)Mine_CoRegisterSurrogate);
    DetourFunctionWithTrampoline((PBYTE)Real_CoReleaseMarshalData,
                                 (PBYTE)Mine_CoReleaseMarshalData);
    DetourFunctionWithTrampoline((PBYTE)Real_CoReleaseServerProcess,
                                 (PBYTE)Mine_CoReleaseServerProcess);
    DetourFunctionWithTrampoline((PBYTE)Real_CoResumeClassObjects,
                                 (PBYTE)Mine_CoResumeClassObjects);
    DetourFunctionWithTrampoline((PBYTE)Real_CoRevertToSelf,
                                 (PBYTE)Mine_CoRevertToSelf);
    DetourFunctionWithTrampoline((PBYTE)Real_CoRevokeClassObject,
                                 (PBYTE)Mine_CoRevokeClassObject);
    DetourFunctionWithTrampoline((PBYTE)Real_CoRevokeMallocSpy,
                                 (PBYTE)Mine_CoRevokeMallocSpy);
    DetourFunctionWithTrampoline((PBYTE)Real_CoSetProxyBlanket,
                                 (PBYTE)Mine_CoSetProxyBlanket);
    DetourFunctionWithTrampoline((PBYTE)Real_CoSuspendClassObjects,
                                 (PBYTE)Mine_CoSuspendClassObjects);
    DetourFunctionWithTrampoline((PBYTE)Real_CoSwitchCallContext,
                                 (PBYTE)Mine_CoSwitchCallContext);
    DetourFunctionWithTrampoline((PBYTE)Real_CoTaskMemAlloc,
                                 (PBYTE)Mine_CoTaskMemAlloc);
    DetourFunctionWithTrampoline((PBYTE)Real_CoTaskMemFree,
                                 (PBYTE)Mine_CoTaskMemFree);
    DetourFunctionWithTrampoline((PBYTE)Real_CoTaskMemRealloc,
                                 (PBYTE)Mine_CoTaskMemRealloc);
    DetourFunctionWithTrampoline((PBYTE)Real_CoTreatAsClass,
                                 (PBYTE)Mine_CoTreatAsClass);
    DetourFunctionWithTrampoline((PBYTE)Real_CoUninitialize,
                                 (PBYTE)Mine_CoUninitialize);
    DetourFunctionWithTrampoline((PBYTE)Real_CoUnmarshalHresult,
                                 (PBYTE)Mine_CoUnmarshalHresult);
    DetourFunctionWithTrampoline((PBYTE)Real_CoUnmarshalInterface,
                                 (PBYTE)Mine_CoUnmarshalInterface);
    DetourFunctionWithTrampoline((PBYTE)Real_ColorMatchToTarget,
                                 (PBYTE)Mine_ColorMatchToTarget);
    DetourFunctionWithTrampoline((PBYTE)Real_CombineRgn,
                                 (PBYTE)Mine_CombineRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_CombineTransform,
                                 (PBYTE)Mine_CombineTransform);
    DetourFunctionWithTrampoline((PBYTE)Real_CommConfigDialogA,
                                 (PBYTE)Mine_CommConfigDialogA);
    DetourFunctionWithTrampoline((PBYTE)Real_CommConfigDialogW,
                                 (PBYTE)Mine_CommConfigDialogW);
    DetourFunctionWithTrampoline((PBYTE)Real_CompareFileTime,
                                 (PBYTE)Mine_CompareFileTime);
    DetourFunctionWithTrampoline((PBYTE)Real_CompareStringA,
                                 (PBYTE)Mine_CompareStringA);
    DetourFunctionWithTrampoline((PBYTE)Real_CompareStringW,
                                 (PBYTE)Mine_CompareStringW);
    DetourFunctionWithTrampoline((PBYTE)Real_ConnectNamedPipe,
                                 (PBYTE)Mine_ConnectNamedPipe);
    DetourFunctionWithTrampoline((PBYTE)Real_ContinueDebugEvent,
                                 (PBYTE)Mine_ContinueDebugEvent);
    DetourFunctionWithTrampoline((PBYTE)Real_ConvertDefaultLocale,
                                 (PBYTE)Mine_ConvertDefaultLocale);
    DetourFunctionWithTrampoline((PBYTE)Real_ConvertThreadToFiber,
                                 (PBYTE)Mine_ConvertThreadToFiber);
    DetourFunctionWithTrampoline((PBYTE)Real_CopyAcceleratorTableA,
                                 (PBYTE)Mine_CopyAcceleratorTableA);
    DetourFunctionWithTrampoline((PBYTE)Real_CopyAcceleratorTableW,
                                 (PBYTE)Mine_CopyAcceleratorTableW);
    DetourFunctionWithTrampoline((PBYTE)Real_CopyEnhMetaFileA,
                                 (PBYTE)Mine_CopyEnhMetaFileA);
    DetourFunctionWithTrampoline((PBYTE)Real_CopyEnhMetaFileW,
                                 (PBYTE)Mine_CopyEnhMetaFileW);
    DetourFunctionWithTrampoline((PBYTE)Real_CopyFileA,
                                 (PBYTE)Mine_CopyFileA);
    DetourFunctionWithTrampoline((PBYTE)Real_CopyFileExA,
                                 (PBYTE)Mine_CopyFileExA);
    DetourFunctionWithTrampoline((PBYTE)Real_CopyFileExW,
                                 (PBYTE)Mine_CopyFileExW);
    DetourFunctionWithTrampoline((PBYTE)Real_CopyFileW,
                                 (PBYTE)Mine_CopyFileW);
    DetourFunctionWithTrampoline((PBYTE)Real_CopyIcon,
                                 (PBYTE)Mine_CopyIcon);
    DetourFunctionWithTrampoline((PBYTE)Real_CopyImage,
                                 (PBYTE)Mine_CopyImage);
    DetourFunctionWithTrampoline((PBYTE)Real_CopyMetaFileA,
                                 (PBYTE)Mine_CopyMetaFileA);
    DetourFunctionWithTrampoline((PBYTE)Real_CopyMetaFileW,
                                 (PBYTE)Mine_CopyMetaFileW);
    DetourFunctionWithTrampoline((PBYTE)Real_CopyRect,
                                 (PBYTE)Mine_CopyRect);
    DetourFunctionWithTrampoline((PBYTE)Real_CountClipboardFormats,
                                 (PBYTE)Mine_CountClipboardFormats);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateAcceleratorTableA,
                                 (PBYTE)Mine_CreateAcceleratorTableA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateAcceleratorTableW,
                                 (PBYTE)Mine_CreateAcceleratorTableW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateAntiMoniker,
                                 (PBYTE)Mine_CreateAntiMoniker);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateBindCtx,
                                 (PBYTE)Mine_CreateBindCtx);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateBitmap,
                                 (PBYTE)Mine_CreateBitmap);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateBitmapIndirect,
                                 (PBYTE)Mine_CreateBitmapIndirect);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateBrushIndirect,
                                 (PBYTE)Mine_CreateBrushIndirect);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateCaret,
                                 (PBYTE)Mine_CreateCaret);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateClassMoniker,
                                 (PBYTE)Mine_CreateClassMoniker);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateColorSpaceA,
                                 (PBYTE)Mine_CreateColorSpaceA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateColorSpaceW,
                                 (PBYTE)Mine_CreateColorSpaceW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateCompatibleBitmap,
                                 (PBYTE)Mine_CreateCompatibleBitmap);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateCompatibleDC,
                                 (PBYTE)Mine_CreateCompatibleDC);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateConsoleScreenBuffer,
                                 (PBYTE)Mine_CreateConsoleScreenBuffer);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateCursor,
                                 (PBYTE)Mine_CreateCursor);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateDCA,
                                 (PBYTE)Mine_CreateDCA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateDCW,
                                 (PBYTE)Mine_CreateDCW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateDIBPatternBrush,
                                 (PBYTE)Mine_CreateDIBPatternBrush);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateDIBPatternBrushPt,
                                 (PBYTE)Mine_CreateDIBPatternBrushPt);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateDIBSection,
                                 (PBYTE)Mine_CreateDIBSection);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateDIBitmap,
                                 (PBYTE)Mine_CreateDIBitmap);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateDataAdviseHolder,
                                 (PBYTE)Mine_CreateDataAdviseHolder);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateDataCache,
                                 (PBYTE)Mine_CreateDataCache);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateDesktopA,
                                 (PBYTE)Mine_CreateDesktopA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateDesktopW,
                                 (PBYTE)Mine_CreateDesktopW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateDialogIndirectParamA,
                                 (PBYTE)Mine_CreateDialogIndirectParamA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateDialogIndirectParamW,
                                 (PBYTE)Mine_CreateDialogIndirectParamW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateDialogParamA,
                                 (PBYTE)Mine_CreateDialogParamA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateDialogParamW,
                                 (PBYTE)Mine_CreateDialogParamW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateDirectoryA,
                                 (PBYTE)Mine_CreateDirectoryA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateDirectoryExA,
                                 (PBYTE)Mine_CreateDirectoryExA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateDirectoryExW,
                                 (PBYTE)Mine_CreateDirectoryExW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateDirectoryW,
                                 (PBYTE)Mine_CreateDirectoryW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateDiscardableBitmap,
                                 (PBYTE)Mine_CreateDiscardableBitmap);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateEllipticRgn,
                                 (PBYTE)Mine_CreateEllipticRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateEllipticRgnIndirect,
                                 (PBYTE)Mine_CreateEllipticRgnIndirect);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateEnhMetaFileA,
                                 (PBYTE)Mine_CreateEnhMetaFileA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateEnhMetaFileW,
                                 (PBYTE)Mine_CreateEnhMetaFileW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateEventA,
                                 (PBYTE)Mine_CreateEventA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateEventW,
                                 (PBYTE)Mine_CreateEventW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateFiber,
                                 (PBYTE)Mine_CreateFiber);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateFileA,
                                 (PBYTE)Mine_CreateFileA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateFileMappingA,
                                 (PBYTE)Mine_CreateFileMappingA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateFileMappingW,
                                 (PBYTE)Mine_CreateFileMappingW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateFileMoniker,
                                 (PBYTE)Mine_CreateFileMoniker);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateFileW,
                                 (PBYTE)Mine_CreateFileW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateFontA,
                                 (PBYTE)Mine_CreateFontA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateFontIndirectA,
                                 (PBYTE)Mine_CreateFontIndirectA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateFontIndirectW,
                                 (PBYTE)Mine_CreateFontIndirectW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateFontW,
                                 (PBYTE)Mine_CreateFontW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateGenericComposite,
                                 (PBYTE)Mine_CreateGenericComposite);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateHalftonePalette,
                                 (PBYTE)Mine_CreateHalftonePalette);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateHatchBrush,
                                 (PBYTE)Mine_CreateHatchBrush);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateICA,
                                 (PBYTE)Mine_CreateICA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateICW,
                                 (PBYTE)Mine_CreateICW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateILockBytesOnHGlobal,
                                 (PBYTE)Mine_CreateILockBytesOnHGlobal);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateIcon,
                                 (PBYTE)Mine_CreateIcon);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateIconFromResource,
                                 (PBYTE)Mine_CreateIconFromResource);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateIconFromResourceEx,
                                 (PBYTE)Mine_CreateIconFromResourceEx);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateIconIndirect,
                                 (PBYTE)Mine_CreateIconIndirect);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateIoCompletionPort,
                                 (PBYTE)Mine_CreateIoCompletionPort);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateItemMoniker,
                                 (PBYTE)Mine_CreateItemMoniker);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateMDIWindowA,
                                 (PBYTE)Mine_CreateMDIWindowA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateMDIWindowW,
                                 (PBYTE)Mine_CreateMDIWindowW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateMailslotA,
                                 (PBYTE)Mine_CreateMailslotA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateMailslotW,
                                 (PBYTE)Mine_CreateMailslotW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateMenu,
                                 (PBYTE)Mine_CreateMenu);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateMetaFileA,
                                 (PBYTE)Mine_CreateMetaFileA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateMetaFileW,
                                 (PBYTE)Mine_CreateMetaFileW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateMutexA,
                                 (PBYTE)Mine_CreateMutexA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateMutexW,
                                 (PBYTE)Mine_CreateMutexW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateNamedPipeA,
                                 (PBYTE)Mine_CreateNamedPipeA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateNamedPipeW,
                                 (PBYTE)Mine_CreateNamedPipeW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateOleAdviseHolder,
                                 (PBYTE)Mine_CreateOleAdviseHolder);
    DetourFunctionWithTrampoline((PBYTE)Real_CreatePalette,
                                 (PBYTE)Mine_CreatePalette);
    DetourFunctionWithTrampoline((PBYTE)Real_CreatePatternBrush,
                                 (PBYTE)Mine_CreatePatternBrush);
    DetourFunctionWithTrampoline((PBYTE)Real_CreatePen,
                                 (PBYTE)Mine_CreatePen);
    DetourFunctionWithTrampoline((PBYTE)Real_CreatePenIndirect,
                                 (PBYTE)Mine_CreatePenIndirect);
    DetourFunctionWithTrampoline((PBYTE)Real_CreatePipe,
                                 (PBYTE)Mine_CreatePipe);
    DetourFunctionWithTrampoline((PBYTE)Real_CreatePointerMoniker,
                                 (PBYTE)Mine_CreatePointerMoniker);
    DetourFunctionWithTrampoline((PBYTE)Real_CreatePolyPolygonRgn,
                                 (PBYTE)Mine_CreatePolyPolygonRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_CreatePolygonRgn,
                                 (PBYTE)Mine_CreatePolygonRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_CreatePopupMenu,
                                 (PBYTE)Mine_CreatePopupMenu);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateProcessA,
                                 (PBYTE)Mine_CreateProcessA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateProcessW,
                                 (PBYTE)Mine_CreateProcessW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateRectRgn,
                                 (PBYTE)Mine_CreateRectRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateRectRgnIndirect,
                                 (PBYTE)Mine_CreateRectRgnIndirect);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateRemoteThread,
                                 (PBYTE)Mine_CreateRemoteThread);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateRoundRectRgn,
                                 (PBYTE)Mine_CreateRoundRectRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateScalableFontResourceA,
                                 (PBYTE)Mine_CreateScalableFontResourceA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateScalableFontResourceW,
                                 (PBYTE)Mine_CreateScalableFontResourceW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateSemaphoreA,
                                 (PBYTE)Mine_CreateSemaphoreA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateSemaphoreW,
                                 (PBYTE)Mine_CreateSemaphoreW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateSolidBrush,
                                 (PBYTE)Mine_CreateSolidBrush);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateStdProgressIndicator,
                                 (PBYTE)Mine_CreateStdProgressIndicator);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateStreamOnHGlobal,
                                 (PBYTE)Mine_CreateStreamOnHGlobal);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateTapePartition,
                                 (PBYTE)Mine_CreateTapePartition);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateThread,
                                 (PBYTE)Mine_CreateThread);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateWaitableTimerA,
                                 (PBYTE)Mine_CreateWaitableTimerA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateWaitableTimerW,
                                 (PBYTE)Mine_CreateWaitableTimerW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateWindowExA,
                                 (PBYTE)Mine_CreateWindowExA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateWindowExW,
                                 (PBYTE)Mine_CreateWindowExW);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateWindowStationA,
                                 (PBYTE)Mine_CreateWindowStationA);
    DetourFunctionWithTrampoline((PBYTE)Real_CreateWindowStationW,
                                 (PBYTE)Mine_CreateWindowStationW);
    DetourFunctionWithTrampoline((PBYTE)Real_DPtoLP,
                                 (PBYTE)Mine_DPtoLP);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeAbandonTransaction,
                                 (PBYTE)Mine_DdeAbandonTransaction);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeAccessData,
                                 (PBYTE)Mine_DdeAccessData);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeAddData,
                                 (PBYTE)Mine_DdeAddData);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeClientTransaction,
                                 (PBYTE)Mine_DdeClientTransaction);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeCmpStringHandles,
                                 (PBYTE)Mine_DdeCmpStringHandles);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeConnect,
                                 (PBYTE)Mine_DdeConnect);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeConnectList,
                                 (PBYTE)Mine_DdeConnectList);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeCreateDataHandle,
                                 (PBYTE)Mine_DdeCreateDataHandle);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeCreateStringHandleA,
                                 (PBYTE)Mine_DdeCreateStringHandleA);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeCreateStringHandleW,
                                 (PBYTE)Mine_DdeCreateStringHandleW);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeDisconnect,
                                 (PBYTE)Mine_DdeDisconnect);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeDisconnectList,
                                 (PBYTE)Mine_DdeDisconnectList);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeEnableCallback,
                                 (PBYTE)Mine_DdeEnableCallback);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeFreeDataHandle,
                                 (PBYTE)Mine_DdeFreeDataHandle);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeFreeStringHandle,
                                 (PBYTE)Mine_DdeFreeStringHandle);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeGetData,
                                 (PBYTE)Mine_DdeGetData);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeGetLastError,
                                 (PBYTE)Mine_DdeGetLastError);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeImpersonateClient,
                                 (PBYTE)Mine_DdeImpersonateClient);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeKeepStringHandle,
                                 (PBYTE)Mine_DdeKeepStringHandle);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeNameService,
                                 (PBYTE)Mine_DdeNameService);
    DetourFunctionWithTrampoline((PBYTE)Real_DdePostAdvise,
                                 (PBYTE)Mine_DdePostAdvise);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeQueryConvInfo,
                                 (PBYTE)Mine_DdeQueryConvInfo);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeQueryNextServer,
                                 (PBYTE)Mine_DdeQueryNextServer);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeQueryStringA,
                                 (PBYTE)Mine_DdeQueryStringA);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeQueryStringW,
                                 (PBYTE)Mine_DdeQueryStringW);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeReconnect,
                                 (PBYTE)Mine_DdeReconnect);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeSetQualityOfService,
                                 (PBYTE)Mine_DdeSetQualityOfService);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeSetUserHandle,
                                 (PBYTE)Mine_DdeSetUserHandle);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeUnaccessData,
                                 (PBYTE)Mine_DdeUnaccessData);
    DetourFunctionWithTrampoline((PBYTE)Real_DdeUninitialize,
                                 (PBYTE)Mine_DdeUninitialize);
    DetourFunctionWithTrampoline((PBYTE)Real_DebugActiveProcess,
                                 (PBYTE)Mine_DebugActiveProcess);
    DetourFunctionWithTrampoline((PBYTE)Real_DebugBreak,
                                 (PBYTE)Mine_DebugBreak);
    DetourFunctionWithTrampoline((PBYTE)Real_DefDlgProcA,
                                 (PBYTE)Mine_DefDlgProcA);
    DetourFunctionWithTrampoline((PBYTE)Real_DefDlgProcW,
                                 (PBYTE)Mine_DefDlgProcW);
    DetourFunctionWithTrampoline((PBYTE)Real_DefFrameProcA,
                                 (PBYTE)Mine_DefFrameProcA);
    DetourFunctionWithTrampoline((PBYTE)Real_DefFrameProcW,
                                 (PBYTE)Mine_DefFrameProcW);
    DetourFunctionWithTrampoline((PBYTE)Real_DefMDIChildProcA,
                                 (PBYTE)Mine_DefMDIChildProcA);
    DetourFunctionWithTrampoline((PBYTE)Real_DefMDIChildProcW,
                                 (PBYTE)Mine_DefMDIChildProcW);
    DetourFunctionWithTrampoline((PBYTE)Real_DefWindowProcA,
                                 (PBYTE)Mine_DefWindowProcA);
    DetourFunctionWithTrampoline((PBYTE)Real_DefWindowProcW,
                                 (PBYTE)Mine_DefWindowProcW);
    DetourFunctionWithTrampoline((PBYTE)Real_DeferWindowPos,
                                 (PBYTE)Mine_DeferWindowPos);
    DetourFunctionWithTrampoline((PBYTE)Real_DefineDosDeviceA,
                                 (PBYTE)Mine_DefineDosDeviceA);
    DetourFunctionWithTrampoline((PBYTE)Real_DefineDosDeviceW,
                                 (PBYTE)Mine_DefineDosDeviceW);
    DetourFunctionWithTrampoline((PBYTE)Real_DeleteAtom,
                                 (PBYTE)Mine_DeleteAtom);
    DetourFunctionWithTrampoline((PBYTE)Real_DeleteColorSpace,
                                 (PBYTE)Mine_DeleteColorSpace);
    DetourFunctionWithTrampoline((PBYTE)Real_DeleteDC,
                                 (PBYTE)Mine_DeleteDC);
    DetourFunctionWithTrampoline((PBYTE)Real_DeleteEnhMetaFile,
                                 (PBYTE)Mine_DeleteEnhMetaFile);
    DetourFunctionWithTrampoline((PBYTE)Real_DeleteFiber,
                                 (PBYTE)Mine_DeleteFiber);
    DetourFunctionWithTrampoline((PBYTE)Real_DeleteFileA,
                                 (PBYTE)Mine_DeleteFileA);
    DetourFunctionWithTrampoline((PBYTE)Real_DeleteFileW,
                                 (PBYTE)Mine_DeleteFileW);
    DetourFunctionWithTrampoline((PBYTE)Real_DeleteMenu,
                                 (PBYTE)Mine_DeleteMenu);
    DetourFunctionWithTrampoline((PBYTE)Real_DeleteMetaFile,
                                 (PBYTE)Mine_DeleteMetaFile);
    DetourFunctionWithTrampoline((PBYTE)Real_DeleteObject,
                                 (PBYTE)Mine_DeleteObject);
    DetourFunctionWithTrampoline((PBYTE)Real_DescribePixelFormat,
                                 (PBYTE)Mine_DescribePixelFormat);
    DetourFunctionWithTrampoline((PBYTE)Real_DestroyAcceleratorTable,
                                 (PBYTE)Mine_DestroyAcceleratorTable);
    DetourFunctionWithTrampoline((PBYTE)Real_DestroyCaret,
                                 (PBYTE)Mine_DestroyCaret);
    DetourFunctionWithTrampoline((PBYTE)Real_DestroyCursor,
                                 (PBYTE)Mine_DestroyCursor);
    DetourFunctionWithTrampoline((PBYTE)Real_DestroyIcon,
                                 (PBYTE)Mine_DestroyIcon);
    DetourFunctionWithTrampoline((PBYTE)Real_DestroyMenu,
                                 (PBYTE)Mine_DestroyMenu);
    DetourFunctionWithTrampoline((PBYTE)Real_DestroyWindow,
                                 (PBYTE)Mine_DestroyWindow);
    DetourFunctionWithTrampoline((PBYTE)Real_DeviceIoControl,
                                 (PBYTE)Mine_DeviceIoControl);
    DetourFunctionWithTrampoline((PBYTE)Real_DialogBoxIndirectParamA,
                                 (PBYTE)Mine_DialogBoxIndirectParamA);
    DetourFunctionWithTrampoline((PBYTE)Real_DialogBoxIndirectParamW,
                                 (PBYTE)Mine_DialogBoxIndirectParamW);
    DetourFunctionWithTrampoline((PBYTE)Real_DialogBoxParamA,
                                 (PBYTE)Mine_DialogBoxParamA);
    DetourFunctionWithTrampoline((PBYTE)Real_DialogBoxParamW,
                                 (PBYTE)Mine_DialogBoxParamW);
    DetourFunctionWithTrampoline((PBYTE)Real_DisableThreadLibraryCalls,
                                 (PBYTE)Mine_DisableThreadLibraryCalls);
    DetourFunctionWithTrampoline((PBYTE)Real_DisconnectNamedPipe,
                                 (PBYTE)Mine_DisconnectNamedPipe);
    DetourFunctionWithTrampoline((PBYTE)Real_DispatchMessageA,
                                 (PBYTE)Mine_DispatchMessageA);
    DetourFunctionWithTrampoline((PBYTE)Real_DispatchMessageW,
                                 (PBYTE)Mine_DispatchMessageW);
    DetourFunctionWithTrampoline((PBYTE)Real_DlgDirListA,
                                 (PBYTE)Mine_DlgDirListA);
    DetourFunctionWithTrampoline((PBYTE)Real_DlgDirListComboBoxA,
                                 (PBYTE)Mine_DlgDirListComboBoxA);
    DetourFunctionWithTrampoline((PBYTE)Real_DlgDirListComboBoxW,
                                 (PBYTE)Mine_DlgDirListComboBoxW);
    DetourFunctionWithTrampoline((PBYTE)Real_DlgDirListW,
                                 (PBYTE)Mine_DlgDirListW);
    DetourFunctionWithTrampoline((PBYTE)Real_DlgDirSelectComboBoxExA,
                                 (PBYTE)Mine_DlgDirSelectComboBoxExA);
    DetourFunctionWithTrampoline((PBYTE)Real_DlgDirSelectComboBoxExW,
                                 (PBYTE)Mine_DlgDirSelectComboBoxExW);
    DetourFunctionWithTrampoline((PBYTE)Real_DlgDirSelectExA,
                                 (PBYTE)Mine_DlgDirSelectExA);
    DetourFunctionWithTrampoline((PBYTE)Real_DlgDirSelectExW,
                                 (PBYTE)Mine_DlgDirSelectExW);
    DetourFunctionWithTrampoline((PBYTE)Real_DoDragDrop,
                                 (PBYTE)Mine_DoDragDrop);
    DetourFunctionWithTrampoline((PBYTE)Real_DosDateTimeToFileTime,
                                 (PBYTE)Mine_DosDateTimeToFileTime);
    DetourFunctionWithTrampoline((PBYTE)Real_DragDetect,
                                 (PBYTE)Mine_DragDetect);
    DetourFunctionWithTrampoline((PBYTE)Real_DragObject,
                                 (PBYTE)Mine_DragObject);
    DetourFunctionWithTrampoline((PBYTE)Real_DrawAnimatedRects,
                                 (PBYTE)Mine_DrawAnimatedRects);
    DetourFunctionWithTrampoline((PBYTE)Real_DrawCaption,
                                 (PBYTE)Mine_DrawCaption);
    DetourFunctionWithTrampoline((PBYTE)Real_DrawEdge,
                                 (PBYTE)Mine_DrawEdge);
    DetourFunctionWithTrampoline((PBYTE)Real_DrawEscape,
                                 (PBYTE)Mine_DrawEscape);
    DetourFunctionWithTrampoline((PBYTE)Real_DrawFocusRect,
                                 (PBYTE)Mine_DrawFocusRect);
    DetourFunctionWithTrampoline((PBYTE)Real_DrawFrameControl,
                                 (PBYTE)Mine_DrawFrameControl);
    DetourFunctionWithTrampoline((PBYTE)Real_DrawIcon,
                                 (PBYTE)Mine_DrawIcon);
    DetourFunctionWithTrampoline((PBYTE)Real_DrawIconEx,
                                 (PBYTE)Mine_DrawIconEx);
    DetourFunctionWithTrampoline((PBYTE)Real_DrawMenuBar,
                                 (PBYTE)Mine_DrawMenuBar);
    DetourFunctionWithTrampoline((PBYTE)Real_DrawStateA,
                                 (PBYTE)Mine_DrawStateA);
    DetourFunctionWithTrampoline((PBYTE)Real_DrawStateW,
                                 (PBYTE)Mine_DrawStateW);
    DetourFunctionWithTrampoline((PBYTE)Real_DrawTextA,
                                 (PBYTE)Mine_DrawTextA);
    DetourFunctionWithTrampoline((PBYTE)Real_DrawTextExA,
                                 (PBYTE)Mine_DrawTextExA);
    DetourFunctionWithTrampoline((PBYTE)Real_DrawTextExW,
                                 (PBYTE)Mine_DrawTextExW);
    DetourFunctionWithTrampoline((PBYTE)Real_DrawTextW,
                                 (PBYTE)Mine_DrawTextW);
    DetourFunctionWithTrampoline((PBYTE)Real_DuplicateHandle,
                                 (PBYTE)Mine_DuplicateHandle);
    DetourFunctionWithTrampoline((PBYTE)Real_Ellipse,
                                 (PBYTE)Mine_Ellipse);
    DetourFunctionWithTrampoline((PBYTE)Real_EmptyClipboard,
                                 (PBYTE)Mine_EmptyClipboard);
    DetourFunctionWithTrampoline((PBYTE)Real_EnableMenuItem,
                                 (PBYTE)Mine_EnableMenuItem);
    DetourFunctionWithTrampoline((PBYTE)Real_EnableScrollBar,
                                 (PBYTE)Mine_EnableScrollBar);
    DetourFunctionWithTrampoline((PBYTE)Real_EnableWindow,
                                 (PBYTE)Mine_EnableWindow);
    DetourFunctionWithTrampoline((PBYTE)Real_EndDeferWindowPos,
                                 (PBYTE)Mine_EndDeferWindowPos);
    DetourFunctionWithTrampoline((PBYTE)Real_EndDialog,
                                 (PBYTE)Mine_EndDialog);
    DetourFunctionWithTrampoline((PBYTE)Real_EndDoc,
                                 (PBYTE)Mine_EndDoc);
    DetourFunctionWithTrampoline((PBYTE)Real_EndPage,
                                 (PBYTE)Mine_EndPage);
    DetourFunctionWithTrampoline((PBYTE)Real_EndPaint,
                                 (PBYTE)Mine_EndPaint);
    DetourFunctionWithTrampoline((PBYTE)Real_EndPath,
                                 (PBYTE)Mine_EndPath);
    DetourFunctionWithTrampoline((PBYTE)Real_EndUpdateResourceA,
                                 (PBYTE)Mine_EndUpdateResourceA);
    DetourFunctionWithTrampoline((PBYTE)Real_EndUpdateResourceW,
                                 (PBYTE)Mine_EndUpdateResourceW);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumCalendarInfoA,
                                 (PBYTE)Mine_EnumCalendarInfoA);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumCalendarInfoW,
                                 (PBYTE)Mine_EnumCalendarInfoW);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumChildWindows,
                                 (PBYTE)Mine_EnumChildWindows);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumClipboardFormats,
                                 (PBYTE)Mine_EnumClipboardFormats);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumDateFormatsA,
                                 (PBYTE)Mine_EnumDateFormatsA);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumDateFormatsW,
                                 (PBYTE)Mine_EnumDateFormatsW);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumDesktopWindows,
                                 (PBYTE)Mine_EnumDesktopWindows);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumDesktopsA,
                                 (PBYTE)Mine_EnumDesktopsA);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumDesktopsW,
                                 (PBYTE)Mine_EnumDesktopsW);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumDisplaySettingsA,
                                 (PBYTE)Mine_EnumDisplaySettingsA);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumDisplaySettingsW,
                                 (PBYTE)Mine_EnumDisplaySettingsW);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumEnhMetaFile,
                                 (PBYTE)Mine_EnumEnhMetaFile);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumFontFamiliesA,
                                 (PBYTE)Mine_EnumFontFamiliesA);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumFontFamiliesExA,
                                 (PBYTE)Mine_EnumFontFamiliesExA);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumFontFamiliesExW,
                                 (PBYTE)Mine_EnumFontFamiliesExW);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumFontFamiliesW,
                                 (PBYTE)Mine_EnumFontFamiliesW);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumFontsA,
                                 (PBYTE)Mine_EnumFontsA);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumFontsW,
                                 (PBYTE)Mine_EnumFontsW);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumICMProfilesA,
                                 (PBYTE)Mine_EnumICMProfilesA);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumICMProfilesW,
                                 (PBYTE)Mine_EnumICMProfilesW);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumMetaFile,
                                 (PBYTE)Mine_EnumMetaFile);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumObjects,
                                 (PBYTE)Mine_EnumObjects);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumPropsA,
                                 (PBYTE)Mine_EnumPropsA);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumPropsExA,
                                 (PBYTE)Mine_EnumPropsExA);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumPropsExW,
                                 (PBYTE)Mine_EnumPropsExW);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumPropsW,
                                 (PBYTE)Mine_EnumPropsW);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumResourceLanguagesA,
                                 (PBYTE)Mine_EnumResourceLanguagesA);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumResourceLanguagesW,
                                 (PBYTE)Mine_EnumResourceLanguagesW);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumResourceNamesA,
                                 (PBYTE)Mine_EnumResourceNamesA);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumResourceNamesW,
                                 (PBYTE)Mine_EnumResourceNamesW);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumResourceTypesA,
                                 (PBYTE)Mine_EnumResourceTypesA);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumResourceTypesW,
                                 (PBYTE)Mine_EnumResourceTypesW);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumSystemCodePagesA,
                                 (PBYTE)Mine_EnumSystemCodePagesA);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumSystemCodePagesW,
                                 (PBYTE)Mine_EnumSystemCodePagesW);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumSystemLocalesA,
                                 (PBYTE)Mine_EnumSystemLocalesA);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumSystemLocalesW,
                                 (PBYTE)Mine_EnumSystemLocalesW);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumThreadWindows,
                                 (PBYTE)Mine_EnumThreadWindows);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumTimeFormatsA,
                                 (PBYTE)Mine_EnumTimeFormatsA);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumTimeFormatsW,
                                 (PBYTE)Mine_EnumTimeFormatsW);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumWindowStationsA,
                                 (PBYTE)Mine_EnumWindowStationsA);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumWindowStationsW,
                                 (PBYTE)Mine_EnumWindowStationsW);
    DetourFunctionWithTrampoline((PBYTE)Real_EnumWindows,
                                 (PBYTE)Mine_EnumWindows);
    DetourFunctionWithTrampoline((PBYTE)Real_EqualRect,
                                 (PBYTE)Mine_EqualRect);
    DetourFunctionWithTrampoline((PBYTE)Real_EqualRgn,
                                 (PBYTE)Mine_EqualRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_EraseTape,
                                 (PBYTE)Mine_EraseTape);
    DetourFunctionWithTrampoline((PBYTE)Real_Escape,
                                 (PBYTE)Mine_Escape);
    DetourFunctionWithTrampoline((PBYTE)Real_EscapeCommFunction,
                                 (PBYTE)Mine_EscapeCommFunction);
    DetourFunctionWithTrampoline((PBYTE)Real_ExcludeClipRect,
                                 (PBYTE)Mine_ExcludeClipRect);
    DetourFunctionWithTrampoline((PBYTE)Real_ExcludeUpdateRgn,
                                 (PBYTE)Mine_ExcludeUpdateRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_ExitProcess,
                                 (PBYTE)Mine_ExitProcess);
    DetourFunctionWithTrampoline((PBYTE)Real_ExitThread,
                                 (PBYTE)Mine_ExitThread);
    DetourFunctionWithTrampoline((PBYTE)Real_ExitWindowsEx,
                                 (PBYTE)Mine_ExitWindowsEx);
    DetourFunctionWithTrampoline((PBYTE)Real_ExpandEnvironmentStringsA,
                                 (PBYTE)Mine_ExpandEnvironmentStringsA);
    DetourFunctionWithTrampoline((PBYTE)Real_ExpandEnvironmentStringsW,
                                 (PBYTE)Mine_ExpandEnvironmentStringsW);
    DetourFunctionWithTrampoline((PBYTE)Real_ExtCreatePen,
                                 (PBYTE)Mine_ExtCreatePen);
    DetourFunctionWithTrampoline((PBYTE)Real_ExtCreateRegion,
                                 (PBYTE)Mine_ExtCreateRegion);
    DetourFunctionWithTrampoline((PBYTE)Real_ExtEscape,
                                 (PBYTE)Mine_ExtEscape);
    DetourFunctionWithTrampoline((PBYTE)Real_ExtFloodFill,
                                 (PBYTE)Mine_ExtFloodFill);
    DetourFunctionWithTrampoline((PBYTE)Real_ExtSelectClipRgn,
                                 (PBYTE)Mine_ExtSelectClipRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_ExtTextOutA,
                                 (PBYTE)Mine_ExtTextOutA);
    DetourFunctionWithTrampoline((PBYTE)Real_ExtTextOutW,
                                 (PBYTE)Mine_ExtTextOutW);
    DetourFunctionWithTrampoline((PBYTE)Real_FatalAppExitA,
                                 (PBYTE)Mine_FatalAppExitA);
    DetourFunctionWithTrampoline((PBYTE)Real_FatalAppExitW,
                                 (PBYTE)Mine_FatalAppExitW);
    DetourFunctionWithTrampoline((PBYTE)Real_FatalExit,
                                 (PBYTE)Mine_FatalExit);
    DetourFunctionWithTrampoline((PBYTE)Real_FileTimeToDosDateTime,
                                 (PBYTE)Mine_FileTimeToDosDateTime);
    DetourFunctionWithTrampoline((PBYTE)Real_FileTimeToLocalFileTime,
                                 (PBYTE)Mine_FileTimeToLocalFileTime);
    DetourFunctionWithTrampoline((PBYTE)Real_FileTimeToSystemTime,
                                 (PBYTE)Mine_FileTimeToSystemTime);
    DetourFunctionWithTrampoline((PBYTE)Real_FillConsoleOutputAttribute,
                                 (PBYTE)Mine_FillConsoleOutputAttribute);
    DetourFunctionWithTrampoline((PBYTE)Real_FillConsoleOutputCharacterA,
                                 (PBYTE)Mine_FillConsoleOutputCharacterA);
    DetourFunctionWithTrampoline((PBYTE)Real_FillConsoleOutputCharacterW,
                                 (PBYTE)Mine_FillConsoleOutputCharacterW);
    DetourFunctionWithTrampoline((PBYTE)Real_FillPath,
                                 (PBYTE)Mine_FillPath);
    DetourFunctionWithTrampoline((PBYTE)Real_FillRect,
                                 (PBYTE)Mine_FillRect);
    DetourFunctionWithTrampoline((PBYTE)Real_FillRgn,
                                 (PBYTE)Mine_FillRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_FindAtomA,
                                 (PBYTE)Mine_FindAtomA);
    DetourFunctionWithTrampoline((PBYTE)Real_FindAtomW,
                                 (PBYTE)Mine_FindAtomW);
    DetourFunctionWithTrampoline((PBYTE)Real_FindClose,
                                 (PBYTE)Mine_FindClose);
    DetourFunctionWithTrampoline((PBYTE)Real_FindCloseChangeNotification,
                                 (PBYTE)Mine_FindCloseChangeNotification);
    DetourFunctionWithTrampoline((PBYTE)Real_FindFirstChangeNotificationA,
                                 (PBYTE)Mine_FindFirstChangeNotificationA);
    DetourFunctionWithTrampoline((PBYTE)Real_FindFirstChangeNotificationW,
                                 (PBYTE)Mine_FindFirstChangeNotificationW);
    DetourFunctionWithTrampoline((PBYTE)Real_FindFirstFileA,
                                 (PBYTE)Mine_FindFirstFileA);
    DetourFunctionWithTrampoline((PBYTE)Real_FindFirstFileExA,
                                 (PBYTE)Mine_FindFirstFileExA);
    DetourFunctionWithTrampoline((PBYTE)Real_FindFirstFileExW,
                                 (PBYTE)Mine_FindFirstFileExW);
    DetourFunctionWithTrampoline((PBYTE)Real_FindFirstFileW,
                                 (PBYTE)Mine_FindFirstFileW);
    DetourFunctionWithTrampoline((PBYTE)Real_FindNextChangeNotification,
                                 (PBYTE)Mine_FindNextChangeNotification);
    DetourFunctionWithTrampoline((PBYTE)Real_FindNextFileA,
                                 (PBYTE)Mine_FindNextFileA);
    DetourFunctionWithTrampoline((PBYTE)Real_FindNextFileW,
                                 (PBYTE)Mine_FindNextFileW);
    DetourFunctionWithTrampoline((PBYTE)Real_FindResourceA,
                                 (PBYTE)Mine_FindResourceA);
    DetourFunctionWithTrampoline((PBYTE)Real_FindResourceExA,
                                 (PBYTE)Mine_FindResourceExA);
    DetourFunctionWithTrampoline((PBYTE)Real_FindResourceExW,
                                 (PBYTE)Mine_FindResourceExW);
    DetourFunctionWithTrampoline((PBYTE)Real_FindResourceW,
                                 (PBYTE)Mine_FindResourceW);
    DetourFunctionWithTrampoline((PBYTE)Real_FindWindowA,
                                 (PBYTE)Mine_FindWindowA);
    DetourFunctionWithTrampoline((PBYTE)Real_FindWindowExA,
                                 (PBYTE)Mine_FindWindowExA);
    DetourFunctionWithTrampoline((PBYTE)Real_FindWindowExW,
                                 (PBYTE)Mine_FindWindowExW);
    DetourFunctionWithTrampoline((PBYTE)Real_FindWindowW,
                                 (PBYTE)Mine_FindWindowW);
    DetourFunctionWithTrampoline((PBYTE)Real_FixBrushOrgEx,
                                 (PBYTE)Mine_FixBrushOrgEx);
    DetourFunctionWithTrampoline((PBYTE)Real_FlashWindow,
                                 (PBYTE)Mine_FlashWindow);
    DetourFunctionWithTrampoline((PBYTE)Real_FlattenPath,
                                 (PBYTE)Mine_FlattenPath);
    DetourFunctionWithTrampoline((PBYTE)Real_FloodFill,
                                 (PBYTE)Mine_FloodFill);
    DetourFunctionWithTrampoline((PBYTE)Real_FlushConsoleInputBuffer,
                                 (PBYTE)Mine_FlushConsoleInputBuffer);
    DetourFunctionWithTrampoline((PBYTE)Real_FlushFileBuffers,
                                 (PBYTE)Mine_FlushFileBuffers);
    DetourFunctionWithTrampoline((PBYTE)Real_FlushViewOfFile,
                                 (PBYTE)Mine_FlushViewOfFile);
    DetourFunctionWithTrampoline((PBYTE)Real_FmtIdToPropStgName,
                                 (PBYTE)Mine_FmtIdToPropStgName);
    DetourFunctionWithTrampoline((PBYTE)Real_FoldStringA,
                                 (PBYTE)Mine_FoldStringA);
    DetourFunctionWithTrampoline((PBYTE)Real_FoldStringW,
                                 (PBYTE)Mine_FoldStringW);
    DetourFunctionWithTrampoline((PBYTE)Real_FormatMessageA,
                                 (PBYTE)Mine_FormatMessageA);
    DetourFunctionWithTrampoline((PBYTE)Real_FormatMessageW,
                                 (PBYTE)Mine_FormatMessageW);
    DetourFunctionWithTrampoline((PBYTE)Real_FrameRect,
                                 (PBYTE)Mine_FrameRect);
    DetourFunctionWithTrampoline((PBYTE)Real_FrameRgn,
                                 (PBYTE)Mine_FrameRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_FreeConsole,
                                 (PBYTE)Mine_FreeConsole);
    DetourFunctionWithTrampoline((PBYTE)Real_FreeDDElParam,
                                 (PBYTE)Mine_FreeDDElParam);
    DetourFunctionWithTrampoline((PBYTE)Real_FreeEnvironmentStringsA,
                                 (PBYTE)Mine_FreeEnvironmentStringsA);
    DetourFunctionWithTrampoline((PBYTE)Real_FreeEnvironmentStringsW,
                                 (PBYTE)Mine_FreeEnvironmentStringsW);
    DetourFunctionWithTrampoline((PBYTE)Real_FreeLibrary,
                                 (PBYTE)Mine_FreeLibrary);
    DetourFunctionWithTrampoline((PBYTE)Real_FreeLibraryAndExitThread,
                                 (PBYTE)Mine_FreeLibraryAndExitThread);
    DetourFunctionWithTrampoline((PBYTE)Real_FreePropVariantArray,
                                 (PBYTE)Mine_FreePropVariantArray);
    DetourFunctionWithTrampoline((PBYTE)Real_FreeResource,
                                 (PBYTE)Mine_FreeResource);
    DetourFunctionWithTrampoline((PBYTE)Real_GdiComment,
                                 (PBYTE)Mine_GdiComment);
    DetourFunctionWithTrampoline((PBYTE)Real_GdiFlush,
                                 (PBYTE)Mine_GdiFlush);
    DetourFunctionWithTrampoline((PBYTE)Real_GdiGetBatchLimit,
                                 (PBYTE)Mine_GdiGetBatchLimit);
    DetourFunctionWithTrampoline((PBYTE)Real_GdiSetBatchLimit,
                                 (PBYTE)Mine_GdiSetBatchLimit);
    DetourFunctionWithTrampoline((PBYTE)Real_GenerateConsoleCtrlEvent,
                                 (PBYTE)Mine_GenerateConsoleCtrlEvent);
    DetourFunctionWithTrampoline((PBYTE)Real_GetACP,
                                 (PBYTE)Mine_GetACP);
    DetourFunctionWithTrampoline((PBYTE)Real_GetActiveWindow,
                                 (PBYTE)Mine_GetActiveWindow);
    DetourFunctionWithTrampoline((PBYTE)Real_GetArcDirection,
                                 (PBYTE)Mine_GetArcDirection);
    DetourFunctionWithTrampoline((PBYTE)Real_GetAspectRatioFilterEx,
                                 (PBYTE)Mine_GetAspectRatioFilterEx);
    DetourFunctionWithTrampoline((PBYTE)Real_GetAsyncKeyState,
                                 (PBYTE)Mine_GetAsyncKeyState);
    DetourFunctionWithTrampoline((PBYTE)Real_GetAtomNameA,
                                 (PBYTE)Mine_GetAtomNameA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetAtomNameW,
                                 (PBYTE)Mine_GetAtomNameW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetBinaryTypeA,
                                 (PBYTE)Mine_GetBinaryTypeA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetBinaryTypeW,
                                 (PBYTE)Mine_GetBinaryTypeW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetBitmapBits,
                                 (PBYTE)Mine_GetBitmapBits);
    DetourFunctionWithTrampoline((PBYTE)Real_GetBitmapDimensionEx,
                                 (PBYTE)Mine_GetBitmapDimensionEx);
    DetourFunctionWithTrampoline((PBYTE)Real_GetBkColor,
                                 (PBYTE)Mine_GetBkColor);
    DetourFunctionWithTrampoline((PBYTE)Real_GetBkMode,
                                 (PBYTE)Mine_GetBkMode);
    DetourFunctionWithTrampoline((PBYTE)Real_GetBoundsRect,
                                 (PBYTE)Mine_GetBoundsRect);
    DetourFunctionWithTrampoline((PBYTE)Real_GetBrushOrgEx,
                                 (PBYTE)Mine_GetBrushOrgEx);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCPInfo,
                                 (PBYTE)Mine_GetCPInfo);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCapture,
                                 (PBYTE)Mine_GetCapture);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCaretBlinkTime,
                                 (PBYTE)Mine_GetCaretBlinkTime);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCaretPos,
                                 (PBYTE)Mine_GetCaretPos);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCharABCWidthsA,
                                 (PBYTE)Mine_GetCharABCWidthsA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCharABCWidthsFloatA,
                                 (PBYTE)Mine_GetCharABCWidthsFloatA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCharABCWidthsFloatW,
                                 (PBYTE)Mine_GetCharABCWidthsFloatW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCharABCWidthsW,
                                 (PBYTE)Mine_GetCharABCWidthsW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCharWidth32A,
                                 (PBYTE)Mine_GetCharWidth32A);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCharWidth32W,
                                 (PBYTE)Mine_GetCharWidth32W);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCharWidthA,
                                 (PBYTE)Mine_GetCharWidthA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCharWidthFloatA,
                                 (PBYTE)Mine_GetCharWidthFloatA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCharWidthFloatW,
                                 (PBYTE)Mine_GetCharWidthFloatW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCharWidthW,
                                 (PBYTE)Mine_GetCharWidthW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCharacterPlacementA,
                                 (PBYTE)Mine_GetCharacterPlacementA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCharacterPlacementW,
                                 (PBYTE)Mine_GetCharacterPlacementW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetClassFile,
                                 (PBYTE)Mine_GetClassFile);
    DetourFunctionWithTrampoline((PBYTE)Real_GetClassInfoA,
                                 (PBYTE)Mine_GetClassInfoA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetClassInfoExA,
                                 (PBYTE)Mine_GetClassInfoExA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetClassInfoExW,
                                 (PBYTE)Mine_GetClassInfoExW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetClassInfoW,
                                 (PBYTE)Mine_GetClassInfoW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetClassLongA,
                                 (PBYTE)Mine_GetClassLongA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetClassLongW,
                                 (PBYTE)Mine_GetClassLongW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetClassNameA,
                                 (PBYTE)Mine_GetClassNameA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetClassNameW,
                                 (PBYTE)Mine_GetClassNameW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetClassWord,
                                 (PBYTE)Mine_GetClassWord);
    DetourFunctionWithTrampoline((PBYTE)Real_GetClientRect,
                                 (PBYTE)Mine_GetClientRect);
    DetourFunctionWithTrampoline((PBYTE)Real_GetClipBox,
                                 (PBYTE)Mine_GetClipBox);
    DetourFunctionWithTrampoline((PBYTE)Real_GetClipCursor,
                                 (PBYTE)Mine_GetClipCursor);
    DetourFunctionWithTrampoline((PBYTE)Real_GetClipRgn,
                                 (PBYTE)Mine_GetClipRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_GetClipboardData,
                                 (PBYTE)Mine_GetClipboardData);
    DetourFunctionWithTrampoline((PBYTE)Real_GetClipboardFormatNameA,
                                 (PBYTE)Mine_GetClipboardFormatNameA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetClipboardFormatNameW,
                                 (PBYTE)Mine_GetClipboardFormatNameW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetClipboardOwner,
                                 (PBYTE)Mine_GetClipboardOwner);
    DetourFunctionWithTrampoline((PBYTE)Real_GetClipboardViewer,
                                 (PBYTE)Mine_GetClipboardViewer);
    DetourFunctionWithTrampoline((PBYTE)Real_GetColorAdjustment,
                                 (PBYTE)Mine_GetColorAdjustment);
    DetourFunctionWithTrampoline((PBYTE)Real_GetColorSpace,
                                 (PBYTE)Mine_GetColorSpace);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCommConfig,
                                 (PBYTE)Mine_GetCommConfig);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCommMask,
                                 (PBYTE)Mine_GetCommMask);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCommModemStatus,
                                 (PBYTE)Mine_GetCommModemStatus);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCommProperties,
                                 (PBYTE)Mine_GetCommProperties);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCommState,
                                 (PBYTE)Mine_GetCommState);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCommTimeouts,
                                 (PBYTE)Mine_GetCommTimeouts);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCommandLineA,
                                 (PBYTE)Mine_GetCommandLineA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCommandLineW,
                                 (PBYTE)Mine_GetCommandLineW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCompressedFileSizeA,
                                 (PBYTE)Mine_GetCompressedFileSizeA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCompressedFileSizeW,
                                 (PBYTE)Mine_GetCompressedFileSizeW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetComputerNameA,
                                 (PBYTE)Mine_GetComputerNameA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetComputerNameW,
                                 (PBYTE)Mine_GetComputerNameW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetConsoleCP,
                                 (PBYTE)Mine_GetConsoleCP);
    DetourFunctionWithTrampoline((PBYTE)Real_GetConsoleCursorInfo,
                                 (PBYTE)Mine_GetConsoleCursorInfo);
    DetourFunctionWithTrampoline((PBYTE)Real_GetConsoleMode,
                                 (PBYTE)Mine_GetConsoleMode);
    DetourFunctionWithTrampoline((PBYTE)Real_GetConsoleOutputCP,
                                 (PBYTE)Mine_GetConsoleOutputCP);
    DetourFunctionWithTrampoline((PBYTE)Real_GetConsoleScreenBufferInfo,
                                 (PBYTE)Mine_GetConsoleScreenBufferInfo);
    DetourFunctionWithTrampoline((PBYTE)Real_GetConsoleTitleA,
                                 (PBYTE)Mine_GetConsoleTitleA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetConsoleTitleW,
                                 (PBYTE)Mine_GetConsoleTitleW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetConvertStg,
                                 (PBYTE)Mine_GetConvertStg);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCurrencyFormatA,
                                 (PBYTE)Mine_GetCurrencyFormatA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCurrencyFormatW,
                                 (PBYTE)Mine_GetCurrencyFormatW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCurrentDirectoryA,
                                 (PBYTE)Mine_GetCurrentDirectoryA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCurrentDirectoryW,
                                 (PBYTE)Mine_GetCurrentDirectoryW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCurrentObject,
                                 (PBYTE)Mine_GetCurrentObject);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCurrentPositionEx,
                                 (PBYTE)Mine_GetCurrentPositionEx);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCurrentProcess,
                                 (PBYTE)Mine_GetCurrentProcess);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCurrentProcessId,
                                 (PBYTE)Mine_GetCurrentProcessId);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCurrentThreadId,
                                 (PBYTE)Mine_GetCurrentThreadId);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCursor,
                                 (PBYTE)Mine_GetCursor);
    DetourFunctionWithTrampoline((PBYTE)Real_GetCursorPos,
                                 (PBYTE)Mine_GetCursorPos);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDC,
                                 (PBYTE)Mine_GetDC);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDCEx,
                                 (PBYTE)Mine_GetDCEx);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDCOrgEx,
                                 (PBYTE)Mine_GetDCOrgEx);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDIBColorTable,
                                 (PBYTE)Mine_GetDIBColorTable);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDIBits,
                                 (PBYTE)Mine_GetDIBits);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDateFormatA,
                                 (PBYTE)Mine_GetDateFormatA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDateFormatW,
                                 (PBYTE)Mine_GetDateFormatW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDefaultCommConfigA,
                                 (PBYTE)Mine_GetDefaultCommConfigA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDefaultCommConfigW,
                                 (PBYTE)Mine_GetDefaultCommConfigW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDesktopWindow,
                                 (PBYTE)Mine_GetDesktopWindow);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDeviceCaps,
                                 (PBYTE)Mine_GetDeviceCaps);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDeviceGammaRamp,
                                 (PBYTE)Mine_GetDeviceGammaRamp);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDialogBaseUnits,
                                 (PBYTE)Mine_GetDialogBaseUnits);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDiskFreeSpaceA,
                                 (PBYTE)Mine_GetDiskFreeSpaceA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDiskFreeSpaceExA,
                                 (PBYTE)Mine_GetDiskFreeSpaceExA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDiskFreeSpaceExW,
                                 (PBYTE)Mine_GetDiskFreeSpaceExW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDiskFreeSpaceW,
                                 (PBYTE)Mine_GetDiskFreeSpaceW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDlgCtrlID,
                                 (PBYTE)Mine_GetDlgCtrlID);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDlgItem,
                                 (PBYTE)Mine_GetDlgItem);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDlgItemInt,
                                 (PBYTE)Mine_GetDlgItemInt);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDlgItemTextA,
                                 (PBYTE)Mine_GetDlgItemTextA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDlgItemTextW,
                                 (PBYTE)Mine_GetDlgItemTextW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDoubleClickTime,
                                 (PBYTE)Mine_GetDoubleClickTime);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDriveTypeA,
                                 (PBYTE)Mine_GetDriveTypeA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetDriveTypeW,
                                 (PBYTE)Mine_GetDriveTypeW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetEnhMetaFileA,
                                 (PBYTE)Mine_GetEnhMetaFileA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetEnhMetaFileBits,
                                 (PBYTE)Mine_GetEnhMetaFileBits);
    DetourFunctionWithTrampoline((PBYTE)Real_GetEnhMetaFileDescriptionA,
                                 (PBYTE)Mine_GetEnhMetaFileDescriptionA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetEnhMetaFileDescriptionW,
                                 (PBYTE)Mine_GetEnhMetaFileDescriptionW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetEnhMetaFileHeader,
                                 (PBYTE)Mine_GetEnhMetaFileHeader);
    DetourFunctionWithTrampoline((PBYTE)Real_GetEnhMetaFilePaletteEntries,
                                 (PBYTE)Mine_GetEnhMetaFilePaletteEntries);
    DetourFunctionWithTrampoline((PBYTE)Real_GetEnhMetaFilePixelFormat,
                                 (PBYTE)Mine_GetEnhMetaFilePixelFormat);
    DetourFunctionWithTrampoline((PBYTE)Real_GetEnhMetaFileW,
                                 (PBYTE)Mine_GetEnhMetaFileW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetEnvironmentStrings,
                                 (PBYTE)Mine_GetEnvironmentStrings);
    DetourFunctionWithTrampoline((PBYTE)Real_GetEnvironmentStringsW,
                                 (PBYTE)Mine_GetEnvironmentStringsW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetEnvironmentVariableA,
                                 (PBYTE)Mine_GetEnvironmentVariableA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetEnvironmentVariableW,
                                 (PBYTE)Mine_GetEnvironmentVariableW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetExitCodeProcess,
                                 (PBYTE)Mine_GetExitCodeProcess);
    DetourFunctionWithTrampoline((PBYTE)Real_GetExitCodeThread,
                                 (PBYTE)Mine_GetExitCodeThread);
    DetourFunctionWithTrampoline((PBYTE)Real_GetFileAttributesA,
                                 (PBYTE)Mine_GetFileAttributesA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetFileAttributesExA,
                                 (PBYTE)Mine_GetFileAttributesExA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetFileAttributesExW,
                                 (PBYTE)Mine_GetFileAttributesExW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetFileAttributesW,
                                 (PBYTE)Mine_GetFileAttributesW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetFileInformationByHandle,
                                 (PBYTE)Mine_GetFileInformationByHandle);
    DetourFunctionWithTrampoline((PBYTE)Real_GetFileSize,
                                 (PBYTE)Mine_GetFileSize);
    DetourFunctionWithTrampoline((PBYTE)Real_GetFileTime,
                                 (PBYTE)Mine_GetFileTime);
    DetourFunctionWithTrampoline((PBYTE)Real_GetFileType,
                                 (PBYTE)Mine_GetFileType);
    DetourFunctionWithTrampoline((PBYTE)Real_GetFocus,
                                 (PBYTE)Mine_GetFocus);
    DetourFunctionWithTrampoline((PBYTE)Real_GetFontData,
                                 (PBYTE)Mine_GetFontData);
    DetourFunctionWithTrampoline((PBYTE)Real_GetFontLanguageInfo,
                                 (PBYTE)Mine_GetFontLanguageInfo);
    DetourFunctionWithTrampoline((PBYTE)Real_GetForegroundWindow,
                                 (PBYTE)Mine_GetForegroundWindow);
    DetourFunctionWithTrampoline((PBYTE)Real_GetFullPathNameA,
                                 (PBYTE)Mine_GetFullPathNameA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetFullPathNameW,
                                 (PBYTE)Mine_GetFullPathNameW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetGlyphOutlineA,
                                 (PBYTE)Mine_GetGlyphOutlineA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetGlyphOutlineW,
                                 (PBYTE)Mine_GetGlyphOutlineW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetGraphicsMode,
                                 (PBYTE)Mine_GetGraphicsMode);
    DetourFunctionWithTrampoline((PBYTE)Real_GetHGlobalFromILockBytes,
                                 (PBYTE)Mine_GetHGlobalFromILockBytes);
    DetourFunctionWithTrampoline((PBYTE)Real_GetHGlobalFromStream,
                                 (PBYTE)Mine_GetHGlobalFromStream);
    DetourFunctionWithTrampoline((PBYTE)Real_GetHandleInformation,
                                 (PBYTE)Mine_GetHandleInformation);
    DetourFunctionWithTrampoline((PBYTE)Real_GetICMProfileA,
                                 (PBYTE)Mine_GetICMProfileA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetICMProfileW,
                                 (PBYTE)Mine_GetICMProfileW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetIconInfo,
                                 (PBYTE)Mine_GetIconInfo);
    DetourFunctionWithTrampoline((PBYTE)Real_GetInputState,
                                 (PBYTE)Mine_GetInputState);
    DetourFunctionWithTrampoline((PBYTE)Real_GetKBCodePage,
                                 (PBYTE)Mine_GetKBCodePage);
    DetourFunctionWithTrampoline((PBYTE)Real_GetKerningPairsA,
                                 (PBYTE)Mine_GetKerningPairsA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetKerningPairsW,
                                 (PBYTE)Mine_GetKerningPairsW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetKeyNameTextA,
                                 (PBYTE)Mine_GetKeyNameTextA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetKeyNameTextW,
                                 (PBYTE)Mine_GetKeyNameTextW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetKeyState,
                                 (PBYTE)Mine_GetKeyState);
    DetourFunctionWithTrampoline((PBYTE)Real_GetKeyboardLayout,
                                 (PBYTE)Mine_GetKeyboardLayout);
    DetourFunctionWithTrampoline((PBYTE)Real_GetKeyboardLayoutList,
                                 (PBYTE)Mine_GetKeyboardLayoutList);
    DetourFunctionWithTrampoline((PBYTE)Real_GetKeyboardLayoutNameA,
                                 (PBYTE)Mine_GetKeyboardLayoutNameA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetKeyboardLayoutNameW,
                                 (PBYTE)Mine_GetKeyboardLayoutNameW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetKeyboardState,
                                 (PBYTE)Mine_GetKeyboardState);
    DetourFunctionWithTrampoline((PBYTE)Real_GetKeyboardType,
                                 (PBYTE)Mine_GetKeyboardType);
    DetourFunctionWithTrampoline((PBYTE)Real_GetLastActivePopup,
                                 (PBYTE)Mine_GetLastActivePopup);
    DetourFunctionWithTrampoline((PBYTE)Real_GetLocalTime,
                                 (PBYTE)Mine_GetLocalTime);
    DetourFunctionWithTrampoline((PBYTE)Real_GetLocaleInfoA,
                                 (PBYTE)Mine_GetLocaleInfoA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetLocaleInfoW,
                                 (PBYTE)Mine_GetLocaleInfoW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetLogColorSpaceA,
                                 (PBYTE)Mine_GetLogColorSpaceA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetLogColorSpaceW,
                                 (PBYTE)Mine_GetLogColorSpaceW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetLogicalDriveStringsA,
                                 (PBYTE)Mine_GetLogicalDriveStringsA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetLogicalDriveStringsW,
                                 (PBYTE)Mine_GetLogicalDriveStringsW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetLogicalDrives,
                                 (PBYTE)Mine_GetLogicalDrives);
    DetourFunctionWithTrampoline((PBYTE)Real_GetMailslotInfo,
                                 (PBYTE)Mine_GetMailslotInfo);
    DetourFunctionWithTrampoline((PBYTE)Real_GetMapMode,
                                 (PBYTE)Mine_GetMapMode);
    DetourFunctionWithTrampoline((PBYTE)Real_GetMenu,
                                 (PBYTE)Mine_GetMenu);
    DetourFunctionWithTrampoline((PBYTE)Real_GetMenuCheckMarkDimensions,
                                 (PBYTE)Mine_GetMenuCheckMarkDimensions);
    DetourFunctionWithTrampoline((PBYTE)Real_GetMenuContextHelpId,
                                 (PBYTE)Mine_GetMenuContextHelpId);
    DetourFunctionWithTrampoline((PBYTE)Real_GetMenuDefaultItem,
                                 (PBYTE)Mine_GetMenuDefaultItem);
    DetourFunctionWithTrampoline((PBYTE)Real_GetMenuItemCount,
                                 (PBYTE)Mine_GetMenuItemCount);
    DetourFunctionWithTrampoline((PBYTE)Real_GetMenuItemID,
                                 (PBYTE)Mine_GetMenuItemID);
    DetourFunctionWithTrampoline((PBYTE)Real_GetMenuItemInfoA,
                                 (PBYTE)Mine_GetMenuItemInfoA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetMenuItemInfoW,
                                 (PBYTE)Mine_GetMenuItemInfoW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetMenuItemRect,
                                 (PBYTE)Mine_GetMenuItemRect);
    DetourFunctionWithTrampoline((PBYTE)Real_GetMenuState,
                                 (PBYTE)Mine_GetMenuState);
    DetourFunctionWithTrampoline((PBYTE)Real_GetMenuStringA,
                                 (PBYTE)Mine_GetMenuStringA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetMenuStringW,
                                 (PBYTE)Mine_GetMenuStringW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetMessageA,
                                 (PBYTE)Mine_GetMessageA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetMessageExtraInfo,
                                 (PBYTE)Mine_GetMessageExtraInfo);
    DetourFunctionWithTrampoline((PBYTE)Real_GetMessagePos,
                                 (PBYTE)Mine_GetMessagePos);
    DetourFunctionWithTrampoline((PBYTE)Real_GetMessageTime,
                                 (PBYTE)Mine_GetMessageTime);
    DetourFunctionWithTrampoline((PBYTE)Real_GetMessageW,
                                 (PBYTE)Mine_GetMessageW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetMetaFileA,
                                 (PBYTE)Mine_GetMetaFileA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetMetaFileBitsEx,
                                 (PBYTE)Mine_GetMetaFileBitsEx);
    DetourFunctionWithTrampoline((PBYTE)Real_GetMetaFileW,
                                 (PBYTE)Mine_GetMetaFileW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetMetaRgn,
                                 (PBYTE)Mine_GetMetaRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_GetMiterLimit,
                                 (PBYTE)Mine_GetMiterLimit);
    DetourFunctionWithTrampoline((PBYTE)Real_GetModuleFileNameA,
                                 (PBYTE)Mine_GetModuleFileNameA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetModuleFileNameW,
                                 (PBYTE)Mine_GetModuleFileNameW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetModuleHandleA,
                                 (PBYTE)Mine_GetModuleHandleA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetModuleHandleW,
                                 (PBYTE)Mine_GetModuleHandleW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetNamedPipeHandleStateA,
                                 (PBYTE)Mine_GetNamedPipeHandleStateA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetNamedPipeHandleStateW,
                                 (PBYTE)Mine_GetNamedPipeHandleStateW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetNamedPipeInfo,
                                 (PBYTE)Mine_GetNamedPipeInfo);
    DetourFunctionWithTrampoline((PBYTE)Real_GetNearestColor,
                                 (PBYTE)Mine_GetNearestColor);
    DetourFunctionWithTrampoline((PBYTE)Real_GetNearestPaletteIndex,
                                 (PBYTE)Mine_GetNearestPaletteIndex);
    DetourFunctionWithTrampoline((PBYTE)Real_GetNextDlgGroupItem,
                                 (PBYTE)Mine_GetNextDlgGroupItem);
    DetourFunctionWithTrampoline((PBYTE)Real_GetNextDlgTabItem,
                                 (PBYTE)Mine_GetNextDlgTabItem);
    DetourFunctionWithTrampoline((PBYTE)Real_GetNumberFormatA,
                                 (PBYTE)Mine_GetNumberFormatA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetNumberFormatW,
                                 (PBYTE)Mine_GetNumberFormatW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetNumberOfConsoleInputEvents,
                                 (PBYTE)Mine_GetNumberOfConsoleInputEvents);
    DetourFunctionWithTrampoline((PBYTE)Real_GetNumberOfConsoleMouseButtons,
                                 (PBYTE)Mine_GetNumberOfConsoleMouseButtons);
    DetourFunctionWithTrampoline((PBYTE)Real_GetOEMCP,
                                 (PBYTE)Mine_GetOEMCP);
    DetourFunctionWithTrampoline((PBYTE)Real_GetObjectA,
                                 (PBYTE)Mine_GetObjectA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetObjectType,
                                 (PBYTE)Mine_GetObjectType);
    DetourFunctionWithTrampoline((PBYTE)Real_GetObjectW,
                                 (PBYTE)Mine_GetObjectW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetOpenClipboardWindow,
                                 (PBYTE)Mine_GetOpenClipboardWindow);
    DetourFunctionWithTrampoline((PBYTE)Real_GetOutlineTextMetricsA,
                                 (PBYTE)Mine_GetOutlineTextMetricsA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetOutlineTextMetricsW,
                                 (PBYTE)Mine_GetOutlineTextMetricsW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetOverlappedResult,
                                 (PBYTE)Mine_GetOverlappedResult);
    DetourFunctionWithTrampoline((PBYTE)Real_GetPaletteEntries,
                                 (PBYTE)Mine_GetPaletteEntries);
    DetourFunctionWithTrampoline((PBYTE)Real_GetParent,
                                 (PBYTE)Mine_GetParent);
    DetourFunctionWithTrampoline((PBYTE)Real_GetPath,
                                 (PBYTE)Mine_GetPath);
    DetourFunctionWithTrampoline((PBYTE)Real_GetPixel,
                                 (PBYTE)Mine_GetPixel);
    DetourFunctionWithTrampoline((PBYTE)Real_GetPixelFormat,
                                 (PBYTE)Mine_GetPixelFormat);
    DetourFunctionWithTrampoline((PBYTE)Real_GetPolyFillMode,
                                 (PBYTE)Mine_GetPolyFillMode);
    DetourFunctionWithTrampoline((PBYTE)Real_GetPriorityClass,
                                 (PBYTE)Mine_GetPriorityClass);
    DetourFunctionWithTrampoline((PBYTE)Real_GetPriorityClipboardFormat,
                                 (PBYTE)Mine_GetPriorityClipboardFormat);
    DetourFunctionWithTrampoline((PBYTE)Real_GetPrivateProfileIntA,
                                 (PBYTE)Mine_GetPrivateProfileIntA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetPrivateProfileIntW,
                                 (PBYTE)Mine_GetPrivateProfileIntW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetPrivateProfileSectionA,
                                 (PBYTE)Mine_GetPrivateProfileSectionA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetPrivateProfileSectionNamesA,
                                 (PBYTE)Mine_GetPrivateProfileSectionNamesA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetPrivateProfileSectionNamesW,
                                 (PBYTE)Mine_GetPrivateProfileSectionNamesW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetPrivateProfileSectionW,
                                 (PBYTE)Mine_GetPrivateProfileSectionW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetPrivateProfileStringA,
                                 (PBYTE)Mine_GetPrivateProfileStringA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetPrivateProfileStringW,
                                 (PBYTE)Mine_GetPrivateProfileStringW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetPrivateProfileStructA,
                                 (PBYTE)Mine_GetPrivateProfileStructA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetPrivateProfileStructW,
                                 (PBYTE)Mine_GetPrivateProfileStructW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetProcAddress,
                                 (PBYTE)Mine_GetProcAddress);
    DetourFunctionWithTrampoline((PBYTE)Real_GetProcessAffinityMask,
                                 (PBYTE)Mine_GetProcessAffinityMask);
    DetourFunctionWithTrampoline((PBYTE)Real_GetProcessHeaps,
                                 (PBYTE)Mine_GetProcessHeaps);
    DetourFunctionWithTrampoline((PBYTE)Real_GetProcessPriorityBoost,
                                 (PBYTE)Mine_GetProcessPriorityBoost);
    DetourFunctionWithTrampoline((PBYTE)Real_GetProcessShutdownParameters,
                                 (PBYTE)Mine_GetProcessShutdownParameters);
    DetourFunctionWithTrampoline((PBYTE)Real_GetProcessTimes,
                                 (PBYTE)Mine_GetProcessTimes);
    DetourFunctionWithTrampoline((PBYTE)Real_GetProcessVersion,
                                 (PBYTE)Mine_GetProcessVersion);
    DetourFunctionWithTrampoline((PBYTE)Real_GetProcessWindowStation,
                                 (PBYTE)Mine_GetProcessWindowStation);
    DetourFunctionWithTrampoline((PBYTE)Real_GetProcessWorkingSetSize,
                                 (PBYTE)Mine_GetProcessWorkingSetSize);
    DetourFunctionWithTrampoline((PBYTE)Real_GetProfileIntA,
                                 (PBYTE)Mine_GetProfileIntA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetProfileIntW,
                                 (PBYTE)Mine_GetProfileIntW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetProfileSectionA,
                                 (PBYTE)Mine_GetProfileSectionA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetProfileSectionW,
                                 (PBYTE)Mine_GetProfileSectionW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetProfileStringA,
                                 (PBYTE)Mine_GetProfileStringA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetProfileStringW,
                                 (PBYTE)Mine_GetProfileStringW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetPropA,
                                 (PBYTE)Mine_GetPropA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetPropW,
                                 (PBYTE)Mine_GetPropW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetQueueStatus,
                                 (PBYTE)Mine_GetQueueStatus);
    DetourFunctionWithTrampoline((PBYTE)Real_GetQueuedCompletionStatus,
                                 (PBYTE)Mine_GetQueuedCompletionStatus);
    DetourFunctionWithTrampoline((PBYTE)Real_GetROP2,
                                 (PBYTE)Mine_GetROP2);
    DetourFunctionWithTrampoline((PBYTE)Real_GetRasterizerCaps,
                                 (PBYTE)Mine_GetRasterizerCaps);
    DetourFunctionWithTrampoline((PBYTE)Real_GetRegionData,
                                 (PBYTE)Mine_GetRegionData);
    DetourFunctionWithTrampoline((PBYTE)Real_GetRgnBox,
                                 (PBYTE)Mine_GetRgnBox);
    DetourFunctionWithTrampoline((PBYTE)Real_GetRunningObjectTable,
                                 (PBYTE)Mine_GetRunningObjectTable);
    DetourFunctionWithTrampoline((PBYTE)Real_GetScrollInfo,
                                 (PBYTE)Mine_GetScrollInfo);
    DetourFunctionWithTrampoline((PBYTE)Real_GetScrollPos,
                                 (PBYTE)Mine_GetScrollPos);
    DetourFunctionWithTrampoline((PBYTE)Real_GetScrollRange,
                                 (PBYTE)Mine_GetScrollRange);
    DetourFunctionWithTrampoline((PBYTE)Real_GetShortPathNameA,
                                 (PBYTE)Mine_GetShortPathNameA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetShortPathNameW,
                                 (PBYTE)Mine_GetShortPathNameW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetStartupInfoA,
                                 (PBYTE)Mine_GetStartupInfoA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetStartupInfoW,
                                 (PBYTE)Mine_GetStartupInfoW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetStdHandle,
                                 (PBYTE)Mine_GetStdHandle);
    DetourFunctionWithTrampoline((PBYTE)Real_GetStockObject,
                                 (PBYTE)Mine_GetStockObject);
    DetourFunctionWithTrampoline((PBYTE)Real_GetStretchBltMode,
                                 (PBYTE)Mine_GetStretchBltMode);
    DetourFunctionWithTrampoline((PBYTE)Real_GetSubMenu,
                                 (PBYTE)Mine_GetSubMenu);
    DetourFunctionWithTrampoline((PBYTE)Real_GetSysColor,
                                 (PBYTE)Mine_GetSysColor);
    DetourFunctionWithTrampoline((PBYTE)Real_GetSysColorBrush,
                                 (PBYTE)Mine_GetSysColorBrush);
    DetourFunctionWithTrampoline((PBYTE)Real_GetSystemDefaultLCID,
                                 (PBYTE)Mine_GetSystemDefaultLCID);
    DetourFunctionWithTrampoline((PBYTE)Real_GetSystemDefaultLangID,
                                 (PBYTE)Mine_GetSystemDefaultLangID);
    DetourFunctionWithTrampoline((PBYTE)Real_GetSystemDirectoryA,
                                 (PBYTE)Mine_GetSystemDirectoryA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetSystemDirectoryW,
                                 (PBYTE)Mine_GetSystemDirectoryW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetSystemInfo,
                                 (PBYTE)Mine_GetSystemInfo);
    DetourFunctionWithTrampoline((PBYTE)Real_GetSystemMenu,
                                 (PBYTE)Mine_GetSystemMenu);
    DetourFunctionWithTrampoline((PBYTE)Real_GetSystemMetrics,
                                 (PBYTE)Mine_GetSystemMetrics);
    DetourFunctionWithTrampoline((PBYTE)Real_GetSystemPaletteEntries,
                                 (PBYTE)Mine_GetSystemPaletteEntries);
    DetourFunctionWithTrampoline((PBYTE)Real_GetSystemPaletteUse,
                                 (PBYTE)Mine_GetSystemPaletteUse);
    DetourFunctionWithTrampoline((PBYTE)Real_GetSystemPowerStatus,
                                 (PBYTE)Mine_GetSystemPowerStatus);
    DetourFunctionWithTrampoline((PBYTE)Real_GetSystemTime,
                                 (PBYTE)Mine_GetSystemTime);
    DetourFunctionWithTrampoline((PBYTE)Real_GetSystemTimeAdjustment,
                                 (PBYTE)Mine_GetSystemTimeAdjustment);
    DetourFunctionWithTrampoline((PBYTE)Real_GetSystemTimeAsFileTime,
                                 (PBYTE)Mine_GetSystemTimeAsFileTime);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTabbedTextExtentA,
                                 (PBYTE)Mine_GetTabbedTextExtentA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTabbedTextExtentW,
                                 (PBYTE)Mine_GetTabbedTextExtentW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTapeParameters,
                                 (PBYTE)Mine_GetTapeParameters);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTapePosition,
                                 (PBYTE)Mine_GetTapePosition);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTapeStatus,
                                 (PBYTE)Mine_GetTapeStatus);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTempFileNameA,
                                 (PBYTE)Mine_GetTempFileNameA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTempFileNameW,
                                 (PBYTE)Mine_GetTempFileNameW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTempPathA,
                                 (PBYTE)Mine_GetTempPathA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTempPathW,
                                 (PBYTE)Mine_GetTempPathW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTextAlign,
                                 (PBYTE)Mine_GetTextAlign);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTextCharacterExtra,
                                 (PBYTE)Mine_GetTextCharacterExtra);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTextCharset,
                                 (PBYTE)Mine_GetTextCharset);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTextCharsetInfo,
                                 (PBYTE)Mine_GetTextCharsetInfo);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTextColor,
                                 (PBYTE)Mine_GetTextColor);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTextExtentExPointA,
                                 (PBYTE)Mine_GetTextExtentExPointA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTextExtentExPointW,
                                 (PBYTE)Mine_GetTextExtentExPointW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTextExtentPoint32A,
                                 (PBYTE)Mine_GetTextExtentPoint32A);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTextExtentPoint32W,
                                 (PBYTE)Mine_GetTextExtentPoint32W);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTextExtentPointA,
                                 (PBYTE)Mine_GetTextExtentPointA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTextExtentPointW,
                                 (PBYTE)Mine_GetTextExtentPointW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTextFaceA,
                                 (PBYTE)Mine_GetTextFaceA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTextFaceW,
                                 (PBYTE)Mine_GetTextFaceW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTextMetricsA,
                                 (PBYTE)Mine_GetTextMetricsA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTextMetricsW,
                                 (PBYTE)Mine_GetTextMetricsW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetThreadContext,
                                 (PBYTE)Mine_GetThreadContext);
    DetourFunctionWithTrampoline((PBYTE)Real_GetThreadDesktop,
                                 (PBYTE)Mine_GetThreadDesktop);
    DetourFunctionWithTrampoline((PBYTE)Real_GetThreadLocale,
                                 (PBYTE)Mine_GetThreadLocale);
    DetourFunctionWithTrampoline((PBYTE)Real_GetThreadPriority,
                                 (PBYTE)Mine_GetThreadPriority);
    DetourFunctionWithTrampoline((PBYTE)Real_GetThreadPriorityBoost,
                                 (PBYTE)Mine_GetThreadPriorityBoost);
    DetourFunctionWithTrampoline((PBYTE)Real_GetThreadSelectorEntry,
                                 (PBYTE)Mine_GetThreadSelectorEntry);
    DetourFunctionWithTrampoline((PBYTE)Real_GetThreadTimes,
                                 (PBYTE)Mine_GetThreadTimes);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTickCount,
                                 (PBYTE)Mine_GetTickCount);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTimeFormatA,
                                 (PBYTE)Mine_GetTimeFormatA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTimeFormatW,
                                 (PBYTE)Mine_GetTimeFormatW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTimeZoneInformation,
                                 (PBYTE)Mine_GetTimeZoneInformation);
    DetourFunctionWithTrampoline((PBYTE)Real_GetTopWindow,
                                 (PBYTE)Mine_GetTopWindow);
    DetourFunctionWithTrampoline((PBYTE)Real_GetUpdateRect,
                                 (PBYTE)Mine_GetUpdateRect);
    DetourFunctionWithTrampoline((PBYTE)Real_GetUpdateRgn,
                                 (PBYTE)Mine_GetUpdateRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_GetUserDefaultLCID,
                                 (PBYTE)Mine_GetUserDefaultLCID);
    DetourFunctionWithTrampoline((PBYTE)Real_GetUserDefaultLangID,
                                 (PBYTE)Mine_GetUserDefaultLangID);
    DetourFunctionWithTrampoline((PBYTE)Real_GetUserObjectInformationA,
                                 (PBYTE)Mine_GetUserObjectInformationA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetUserObjectInformationW,
                                 (PBYTE)Mine_GetUserObjectInformationW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetUserObjectSecurity,
                                 (PBYTE)Mine_GetUserObjectSecurity);
    DetourFunctionWithTrampoline((PBYTE)Real_GetVersion,
                                 (PBYTE)Mine_GetVersion);
    DetourFunctionWithTrampoline((PBYTE)Real_GetVersionExA,
                                 (PBYTE)Mine_GetVersionExA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetVersionExW,
                                 (PBYTE)Mine_GetVersionExW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetViewportExtEx,
                                 (PBYTE)Mine_GetViewportExtEx);
    DetourFunctionWithTrampoline((PBYTE)Real_GetViewportOrgEx,
                                 (PBYTE)Mine_GetViewportOrgEx);
    DetourFunctionWithTrampoline((PBYTE)Real_GetVolumeInformationA,
                                 (PBYTE)Mine_GetVolumeInformationA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetVolumeInformationW,
                                 (PBYTE)Mine_GetVolumeInformationW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetWinMetaFileBits,
                                 (PBYTE)Mine_GetWinMetaFileBits);
    DetourFunctionWithTrampoline((PBYTE)Real_GetWindow,
                                 (PBYTE)Mine_GetWindow);
    DetourFunctionWithTrampoline((PBYTE)Real_GetWindowContextHelpId,
                                 (PBYTE)Mine_GetWindowContextHelpId);
    DetourFunctionWithTrampoline((PBYTE)Real_GetWindowDC,
                                 (PBYTE)Mine_GetWindowDC);
    DetourFunctionWithTrampoline((PBYTE)Real_GetWindowExtEx,
                                 (PBYTE)Mine_GetWindowExtEx);
    DetourFunctionWithTrampoline((PBYTE)Real_GetWindowLongA,
                                 (PBYTE)Mine_GetWindowLongA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetWindowLongW,
                                 (PBYTE)Mine_GetWindowLongW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetWindowOrgEx,
                                 (PBYTE)Mine_GetWindowOrgEx);
    DetourFunctionWithTrampoline((PBYTE)Real_GetWindowPlacement,
                                 (PBYTE)Mine_GetWindowPlacement);
    DetourFunctionWithTrampoline((PBYTE)Real_GetWindowRect,
                                 (PBYTE)Mine_GetWindowRect);
    DetourFunctionWithTrampoline((PBYTE)Real_GetWindowRgn,
                                 (PBYTE)Mine_GetWindowRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_GetWindowTextA,
                                 (PBYTE)Mine_GetWindowTextA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetWindowTextLengthA,
                                 (PBYTE)Mine_GetWindowTextLengthA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetWindowTextLengthW,
                                 (PBYTE)Mine_GetWindowTextLengthW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetWindowTextW,
                                 (PBYTE)Mine_GetWindowTextW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetWindowThreadProcessId,
                                 (PBYTE)Mine_GetWindowThreadProcessId);
    DetourFunctionWithTrampoline((PBYTE)Real_GetWindowWord,
                                 (PBYTE)Mine_GetWindowWord);
    DetourFunctionWithTrampoline((PBYTE)Real_GetWindowsDirectoryA,
                                 (PBYTE)Mine_GetWindowsDirectoryA);
    DetourFunctionWithTrampoline((PBYTE)Real_GetWindowsDirectoryW,
                                 (PBYTE)Mine_GetWindowsDirectoryW);
    DetourFunctionWithTrampoline((PBYTE)Real_GetWorldTransform,
                                 (PBYTE)Mine_GetWorldTransform);
    DetourFunctionWithTrampoline((PBYTE)Real_GlobalAddAtomA,
                                 (PBYTE)Mine_GlobalAddAtomA);
    DetourFunctionWithTrampoline((PBYTE)Real_GlobalAddAtomW,
                                 (PBYTE)Mine_GlobalAddAtomW);
    DetourFunctionWithTrampoline((PBYTE)Real_GlobalAlloc,
                                 (PBYTE)Mine_GlobalAlloc);
    DetourFunctionWithTrampoline((PBYTE)Real_GlobalCompact,
                                 (PBYTE)Mine_GlobalCompact);
    DetourFunctionWithTrampoline((PBYTE)Real_GlobalDeleteAtom,
                                 (PBYTE)Mine_GlobalDeleteAtom);
    DetourFunctionWithTrampoline((PBYTE)Real_GlobalFindAtomA,
                                 (PBYTE)Mine_GlobalFindAtomA);
    DetourFunctionWithTrampoline((PBYTE)Real_GlobalFindAtomW,
                                 (PBYTE)Mine_GlobalFindAtomW);
    DetourFunctionWithTrampoline((PBYTE)Real_GlobalFix,
                                 (PBYTE)Mine_GlobalFix);
    DetourFunctionWithTrampoline((PBYTE)Real_GlobalFlags,
                                 (PBYTE)Mine_GlobalFlags);
    DetourFunctionWithTrampoline((PBYTE)Real_GlobalFree,
                                 (PBYTE)Mine_GlobalFree);
    DetourFunctionWithTrampoline((PBYTE)Real_GlobalGetAtomNameA,
                                 (PBYTE)Mine_GlobalGetAtomNameA);
    DetourFunctionWithTrampoline((PBYTE)Real_GlobalGetAtomNameW,
                                 (PBYTE)Mine_GlobalGetAtomNameW);
    DetourFunctionWithTrampoline((PBYTE)Real_GlobalHandle,
                                 (PBYTE)Mine_GlobalHandle);
    DetourFunctionWithTrampoline((PBYTE)Real_GlobalLock,
                                 (PBYTE)Mine_GlobalLock);
    DetourFunctionWithTrampoline((PBYTE)Real_GlobalMemoryStatus,
                                 (PBYTE)Mine_GlobalMemoryStatus);
    DetourFunctionWithTrampoline((PBYTE)Real_GlobalReAlloc,
                                 (PBYTE)Mine_GlobalReAlloc);
    DetourFunctionWithTrampoline((PBYTE)Real_GlobalSize,
                                 (PBYTE)Mine_GlobalSize);
    DetourFunctionWithTrampoline((PBYTE)Real_GlobalUnWire,
                                 (PBYTE)Mine_GlobalUnWire);
    DetourFunctionWithTrampoline((PBYTE)Real_GlobalUnfix,
                                 (PBYTE)Mine_GlobalUnfix);
    DetourFunctionWithTrampoline((PBYTE)Real_GlobalUnlock,
                                 (PBYTE)Mine_GlobalUnlock);
    DetourFunctionWithTrampoline((PBYTE)Real_GlobalWire,
                                 (PBYTE)Mine_GlobalWire);
    DetourFunctionWithTrampoline((PBYTE)Real_GrayStringA,
                                 (PBYTE)Mine_GrayStringA);
    DetourFunctionWithTrampoline((PBYTE)Real_GrayStringW,
                                 (PBYTE)Mine_GrayStringW);
    DetourFunctionWithTrampoline((PBYTE)Real_HeapLock,
                                 (PBYTE)Mine_HeapLock);
    DetourFunctionWithTrampoline((PBYTE)Real_HeapUnlock,
                                 (PBYTE)Mine_HeapUnlock);
    DetourFunctionWithTrampoline((PBYTE)Real_HideCaret,
                                 (PBYTE)Mine_HideCaret);
    DetourFunctionWithTrampoline((PBYTE)Real_HiliteMenuItem,
                                 (PBYTE)Mine_HiliteMenuItem);
    DetourFunctionWithTrampoline((PBYTE)Real_IIDFromString,
                                 (PBYTE)Mine_IIDFromString);
    DetourFunctionWithTrampoline((PBYTE)Real_ImpersonateDdeClientWindow,
                                 (PBYTE)Mine_ImpersonateDdeClientWindow);
    DetourFunctionWithTrampoline((PBYTE)Real_InSendMessage,
                                 (PBYTE)Mine_InSendMessage);
    DetourFunctionWithTrampoline((PBYTE)Real_InflateRect,
                                 (PBYTE)Mine_InflateRect);
    DetourFunctionWithTrampoline((PBYTE)Real_InitAtomTable,
                                 (PBYTE)Mine_InitAtomTable);
    DetourFunctionWithTrampoline((PBYTE)Real_InsertMenuA,
                                 (PBYTE)Mine_InsertMenuA);
    DetourFunctionWithTrampoline((PBYTE)Real_InsertMenuItemA,
                                 (PBYTE)Mine_InsertMenuItemA);
    DetourFunctionWithTrampoline((PBYTE)Real_InsertMenuItemW,
                                 (PBYTE)Mine_InsertMenuItemW);
    DetourFunctionWithTrampoline((PBYTE)Real_InsertMenuW,
                                 (PBYTE)Mine_InsertMenuW);
    DetourFunctionWithTrampoline((PBYTE)Real_IntersectClipRect,
                                 (PBYTE)Mine_IntersectClipRect);
    DetourFunctionWithTrampoline((PBYTE)Real_IntersectRect,
                                 (PBYTE)Mine_IntersectRect);
    DetourFunctionWithTrampoline((PBYTE)Real_InvalidateRect,
                                 (PBYTE)Mine_InvalidateRect);
    DetourFunctionWithTrampoline((PBYTE)Real_InvalidateRgn,
                                 (PBYTE)Mine_InvalidateRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_InvertRect,
                                 (PBYTE)Mine_InvertRect);
    DetourFunctionWithTrampoline((PBYTE)Real_InvertRgn,
                                 (PBYTE)Mine_InvertRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_IsAccelerator,
                                 (PBYTE)Mine_IsAccelerator);
    DetourFunctionWithTrampoline((PBYTE)Real_IsBadCodePtr,
                                 (PBYTE)Mine_IsBadCodePtr);
    DetourFunctionWithTrampoline((PBYTE)Real_IsBadHugeReadPtr,
                                 (PBYTE)Mine_IsBadHugeReadPtr);
    DetourFunctionWithTrampoline((PBYTE)Real_IsBadHugeWritePtr,
                                 (PBYTE)Mine_IsBadHugeWritePtr);
    DetourFunctionWithTrampoline((PBYTE)Real_IsBadReadPtr,
                                 (PBYTE)Mine_IsBadReadPtr);
    DetourFunctionWithTrampoline((PBYTE)Real_IsBadStringPtrA,
                                 (PBYTE)Mine_IsBadStringPtrA);
    DetourFunctionWithTrampoline((PBYTE)Real_IsBadStringPtrW,
                                 (PBYTE)Mine_IsBadStringPtrW);
    DetourFunctionWithTrampoline((PBYTE)Real_IsBadWritePtr,
                                 (PBYTE)Mine_IsBadWritePtr);
    DetourFunctionWithTrampoline((PBYTE)Real_IsCharAlphaA,
                                 (PBYTE)Mine_IsCharAlphaA);
    DetourFunctionWithTrampoline((PBYTE)Real_IsCharAlphaNumericA,
                                 (PBYTE)Mine_IsCharAlphaNumericA);
    DetourFunctionWithTrampoline((PBYTE)Real_IsCharAlphaNumericW,
                                 (PBYTE)Mine_IsCharAlphaNumericW);
    DetourFunctionWithTrampoline((PBYTE)Real_IsCharAlphaW,
                                 (PBYTE)Mine_IsCharAlphaW);
    DetourFunctionWithTrampoline((PBYTE)Real_IsCharLowerA,
                                 (PBYTE)Mine_IsCharLowerA);
    DetourFunctionWithTrampoline((PBYTE)Real_IsCharLowerW,
                                 (PBYTE)Mine_IsCharLowerW);
    DetourFunctionWithTrampoline((PBYTE)Real_IsCharUpperA,
                                 (PBYTE)Mine_IsCharUpperA);
    DetourFunctionWithTrampoline((PBYTE)Real_IsCharUpperW,
                                 (PBYTE)Mine_IsCharUpperW);
    DetourFunctionWithTrampoline((PBYTE)Real_IsChild,
                                 (PBYTE)Mine_IsChild);
    DetourFunctionWithTrampoline((PBYTE)Real_IsClipboardFormatAvailable,
                                 (PBYTE)Mine_IsClipboardFormatAvailable);
    DetourFunctionWithTrampoline((PBYTE)Real_IsDBCSLeadByte,
                                 (PBYTE)Mine_IsDBCSLeadByte);
    DetourFunctionWithTrampoline((PBYTE)Real_IsDBCSLeadByteEx,
                                 (PBYTE)Mine_IsDBCSLeadByteEx);
    DetourFunctionWithTrampoline((PBYTE)Real_IsDebuggerPresent,
                                 (PBYTE)Mine_IsDebuggerPresent);
    DetourFunctionWithTrampoline((PBYTE)Real_IsDialogMessageA,
                                 (PBYTE)Mine_IsDialogMessageA);
    DetourFunctionWithTrampoline((PBYTE)Real_IsDialogMessageW,
                                 (PBYTE)Mine_IsDialogMessageW);
    DetourFunctionWithTrampoline((PBYTE)Real_IsDlgButtonChecked,
                                 (PBYTE)Mine_IsDlgButtonChecked);
    DetourFunctionWithTrampoline((PBYTE)Real_IsIconic,
                                 (PBYTE)Mine_IsIconic);
    DetourFunctionWithTrampoline((PBYTE)Real_IsMenu,
                                 (PBYTE)Mine_IsMenu);
    DetourFunctionWithTrampoline((PBYTE)Real_IsProcessorFeaturePresent,
                                 (PBYTE)Mine_IsProcessorFeaturePresent);
    DetourFunctionWithTrampoline((PBYTE)Real_IsRectEmpty,
                                 (PBYTE)Mine_IsRectEmpty);
    DetourFunctionWithTrampoline((PBYTE)Real_IsValidCodePage,
                                 (PBYTE)Mine_IsValidCodePage);
    DetourFunctionWithTrampoline((PBYTE)Real_IsValidLocale,
                                 (PBYTE)Mine_IsValidLocale);
    DetourFunctionWithTrampoline((PBYTE)Real_IsWindow,
                                 (PBYTE)Mine_IsWindow);
    DetourFunctionWithTrampoline((PBYTE)Real_IsWindowEnabled,
                                 (PBYTE)Mine_IsWindowEnabled);
    DetourFunctionWithTrampoline((PBYTE)Real_IsWindowUnicode,
                                 (PBYTE)Mine_IsWindowUnicode);
    DetourFunctionWithTrampoline((PBYTE)Real_IsWindowVisible,
                                 (PBYTE)Mine_IsWindowVisible);
    DetourFunctionWithTrampoline((PBYTE)Real_IsZoomed,
                                 (PBYTE)Mine_IsZoomed);
    DetourFunctionWithTrampoline((PBYTE)Real_KillTimer,
                                 (PBYTE)Mine_KillTimer);
    DetourFunctionWithTrampoline((PBYTE)Real_LPtoDP,
                                 (PBYTE)Mine_LPtoDP);
    DetourFunctionWithTrampoline((PBYTE)Real_LineDDA,
                                 (PBYTE)Mine_LineDDA);
    DetourFunctionWithTrampoline((PBYTE)Real_LineTo,
                                 (PBYTE)Mine_LineTo);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadAcceleratorsA,
                                 (PBYTE)Mine_LoadAcceleratorsA);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadAcceleratorsW,
                                 (PBYTE)Mine_LoadAcceleratorsW);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadBitmapA,
                                 (PBYTE)Mine_LoadBitmapA);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadBitmapW,
                                 (PBYTE)Mine_LoadBitmapW);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadCursorA,
                                 (PBYTE)Mine_LoadCursorA);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadCursorFromFileA,
                                 (PBYTE)Mine_LoadCursorFromFileA);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadCursorFromFileW,
                                 (PBYTE)Mine_LoadCursorFromFileW);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadCursorW,
                                 (PBYTE)Mine_LoadCursorW);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadIconA,
                                 (PBYTE)Mine_LoadIconA);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadIconW,
                                 (PBYTE)Mine_LoadIconW);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadImageA,
                                 (PBYTE)Mine_LoadImageA);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadImageW,
                                 (PBYTE)Mine_LoadImageW);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadKeyboardLayoutA,
                                 (PBYTE)Mine_LoadKeyboardLayoutA);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadKeyboardLayoutW,
                                 (PBYTE)Mine_LoadKeyboardLayoutW);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadLibraryA,
                                 (PBYTE)Mine_LoadLibraryA);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadLibraryExA,
                                 (PBYTE)Mine_LoadLibraryExA);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadLibraryExW,
                                 (PBYTE)Mine_LoadLibraryExW);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadLibraryW,
                                 (PBYTE)Mine_LoadLibraryW);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadMenuA,
                                 (PBYTE)Mine_LoadMenuA);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadMenuIndirectA,
                                 (PBYTE)Mine_LoadMenuIndirectA);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadMenuIndirectW,
                                 (PBYTE)Mine_LoadMenuIndirectW);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadMenuW,
                                 (PBYTE)Mine_LoadMenuW);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadModule,
                                 (PBYTE)Mine_LoadModule);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadResource,
                                 (PBYTE)Mine_LoadResource);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadStringA,
                                 (PBYTE)Mine_LoadStringA);
    DetourFunctionWithTrampoline((PBYTE)Real_LoadStringW,
                                 (PBYTE)Mine_LoadStringW);
    DetourFunctionWithTrampoline((PBYTE)Real_LocalAlloc,
                                 (PBYTE)Mine_LocalAlloc);
    DetourFunctionWithTrampoline((PBYTE)Real_LocalCompact,
                                 (PBYTE)Mine_LocalCompact);
    DetourFunctionWithTrampoline((PBYTE)Real_LocalFileTimeToFileTime,
                                 (PBYTE)Mine_LocalFileTimeToFileTime);
    DetourFunctionWithTrampoline((PBYTE)Real_LocalFlags,
                                 (PBYTE)Mine_LocalFlags);
    DetourFunctionWithTrampoline((PBYTE)Real_LocalFree,
                                 (PBYTE)Mine_LocalFree);
    DetourFunctionWithTrampoline((PBYTE)Real_LocalHandle,
                                 (PBYTE)Mine_LocalHandle);
    DetourFunctionWithTrampoline((PBYTE)Real_LocalLock,
                                 (PBYTE)Mine_LocalLock);
    DetourFunctionWithTrampoline((PBYTE)Real_LocalReAlloc,
                                 (PBYTE)Mine_LocalReAlloc);
    DetourFunctionWithTrampoline((PBYTE)Real_LocalShrink,
                                 (PBYTE)Mine_LocalShrink);
    DetourFunctionWithTrampoline((PBYTE)Real_LocalSize,
                                 (PBYTE)Mine_LocalSize);
    DetourFunctionWithTrampoline((PBYTE)Real_LocalUnlock,
                                 (PBYTE)Mine_LocalUnlock);
    DetourFunctionWithTrampoline((PBYTE)Real_LockFile,
                                 (PBYTE)Mine_LockFile);
    DetourFunctionWithTrampoline((PBYTE)Real_LockFileEx,
                                 (PBYTE)Mine_LockFileEx);
    DetourFunctionWithTrampoline((PBYTE)Real_LockResource,
                                 (PBYTE)Mine_LockResource);
    DetourFunctionWithTrampoline((PBYTE)Real_LockWindowUpdate,
                                 (PBYTE)Mine_LockWindowUpdate);
    DetourFunctionWithTrampoline((PBYTE)Real_LookupIconIdFromDirectory,
                                 (PBYTE)Mine_LookupIconIdFromDirectory);
    DetourFunctionWithTrampoline((PBYTE)Real_LookupIconIdFromDirectoryEx,
                                 (PBYTE)Mine_LookupIconIdFromDirectoryEx);
    DetourFunctionWithTrampoline((PBYTE)Real_MapDialogRect,
                                 (PBYTE)Mine_MapDialogRect);
    DetourFunctionWithTrampoline((PBYTE)Real_MapViewOfFile,
                                 (PBYTE)Mine_MapViewOfFile);
    DetourFunctionWithTrampoline((PBYTE)Real_MapViewOfFileEx,
                                 (PBYTE)Mine_MapViewOfFileEx);
    DetourFunctionWithTrampoline((PBYTE)Real_MapVirtualKeyA,
                                 (PBYTE)Mine_MapVirtualKeyA);
    DetourFunctionWithTrampoline((PBYTE)Real_MapVirtualKeyExA,
                                 (PBYTE)Mine_MapVirtualKeyExA);
    DetourFunctionWithTrampoline((PBYTE)Real_MapVirtualKeyExW,
                                 (PBYTE)Mine_MapVirtualKeyExW);
    DetourFunctionWithTrampoline((PBYTE)Real_MapVirtualKeyW,
                                 (PBYTE)Mine_MapVirtualKeyW);
    DetourFunctionWithTrampoline((PBYTE)Real_MapWindowPoints,
                                 (PBYTE)Mine_MapWindowPoints);
    DetourFunctionWithTrampoline((PBYTE)Real_MaskBlt,
                                 (PBYTE)Mine_MaskBlt);
    DetourFunctionWithTrampoline((PBYTE)Real_MenuItemFromPoint,
                                 (PBYTE)Mine_MenuItemFromPoint);
    DetourFunctionWithTrampoline((PBYTE)Real_MessageBeep,
                                 (PBYTE)Mine_MessageBeep);
    DetourFunctionWithTrampoline((PBYTE)Real_MessageBoxA,
                                 (PBYTE)Mine_MessageBoxA);
    DetourFunctionWithTrampoline((PBYTE)Real_MessageBoxExA,
                                 (PBYTE)Mine_MessageBoxExA);
    DetourFunctionWithTrampoline((PBYTE)Real_MessageBoxExW,
                                 (PBYTE)Mine_MessageBoxExW);
    DetourFunctionWithTrampoline((PBYTE)Real_MessageBoxIndirectA,
                                 (PBYTE)Mine_MessageBoxIndirectA);
    DetourFunctionWithTrampoline((PBYTE)Real_MessageBoxIndirectW,
                                 (PBYTE)Mine_MessageBoxIndirectW);
    DetourFunctionWithTrampoline((PBYTE)Real_MessageBoxW,
                                 (PBYTE)Mine_MessageBoxW);
    DetourFunctionWithTrampoline((PBYTE)Real_MkParseDisplayName,
                                 (PBYTE)Mine_MkParseDisplayName);
    DetourFunctionWithTrampoline((PBYTE)Real_ModifyMenuA,
                                 (PBYTE)Mine_ModifyMenuA);
    DetourFunctionWithTrampoline((PBYTE)Real_ModifyMenuW,
                                 (PBYTE)Mine_ModifyMenuW);
    DetourFunctionWithTrampoline((PBYTE)Real_ModifyWorldTransform,
                                 (PBYTE)Mine_ModifyWorldTransform);
    DetourFunctionWithTrampoline((PBYTE)Real_MonikerCommonPrefixWith,
                                 (PBYTE)Mine_MonikerCommonPrefixWith);
    DetourFunctionWithTrampoline((PBYTE)Real_MonikerRelativePathTo,
                                 (PBYTE)Mine_MonikerRelativePathTo);
    DetourFunctionWithTrampoline((PBYTE)Real_MoveFileA,
                                 (PBYTE)Mine_MoveFileA);
    DetourFunctionWithTrampoline((PBYTE)Real_MoveFileExA,
                                 (PBYTE)Mine_MoveFileExA);
    DetourFunctionWithTrampoline((PBYTE)Real_MoveFileExW,
                                 (PBYTE)Mine_MoveFileExW);
    DetourFunctionWithTrampoline((PBYTE)Real_MoveFileW,
                                 (PBYTE)Mine_MoveFileW);
    DetourFunctionWithTrampoline((PBYTE)Real_MoveToEx,
                                 (PBYTE)Mine_MoveToEx);
    DetourFunctionWithTrampoline((PBYTE)Real_MoveWindow,
                                 (PBYTE)Mine_MoveWindow);
    DetourFunctionWithTrampoline((PBYTE)Real_MsgWaitForMultipleObjects,
                                 (PBYTE)Mine_MsgWaitForMultipleObjects);
    DetourFunctionWithTrampoline((PBYTE)Real_MsgWaitForMultipleObjectsEx,
                                 (PBYTE)Mine_MsgWaitForMultipleObjectsEx);
    DetourFunctionWithTrampoline((PBYTE)Real_MulDiv,
                                 (PBYTE)Mine_MulDiv);
    DetourFunctionWithTrampoline((PBYTE)Real_OemKeyScan,
                                 (PBYTE)Mine_OemKeyScan);
    DetourFunctionWithTrampoline((PBYTE)Real_OemToCharA,
                                 (PBYTE)Mine_OemToCharA);
    DetourFunctionWithTrampoline((PBYTE)Real_OemToCharBuffA,
                                 (PBYTE)Mine_OemToCharBuffA);
    DetourFunctionWithTrampoline((PBYTE)Real_OemToCharBuffW,
                                 (PBYTE)Mine_OemToCharBuffW);
    DetourFunctionWithTrampoline((PBYTE)Real_OemToCharW,
                                 (PBYTE)Mine_OemToCharW);
    DetourFunctionWithTrampoline((PBYTE)Real_OffsetClipRgn,
                                 (PBYTE)Mine_OffsetClipRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_OffsetRect,
                                 (PBYTE)Mine_OffsetRect);
    DetourFunctionWithTrampoline((PBYTE)Real_OffsetRgn,
                                 (PBYTE)Mine_OffsetRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_OffsetViewportOrgEx,
                                 (PBYTE)Mine_OffsetViewportOrgEx);
    DetourFunctionWithTrampoline((PBYTE)Real_OffsetWindowOrgEx,
                                 (PBYTE)Mine_OffsetWindowOrgEx);
    DetourFunctionWithTrampoline((PBYTE)Real_OleBuildVersion,
                                 (PBYTE)Mine_OleBuildVersion);
    DetourFunctionWithTrampoline((PBYTE)Real_OleConvertIStorageToOLESTREAM,
                                 (PBYTE)Mine_OleConvertIStorageToOLESTREAM);
    DetourFunctionWithTrampoline((PBYTE)Real_OleConvertIStorageToOLESTREAMEx,
                                 (PBYTE)Mine_OleConvertIStorageToOLESTREAMEx);
    DetourFunctionWithTrampoline((PBYTE)Real_OleConvertOLESTREAMToIStorage,
                                 (PBYTE)Mine_OleConvertOLESTREAMToIStorage);
    DetourFunctionWithTrampoline((PBYTE)Real_OleConvertOLESTREAMToIStorageEx,
                                 (PBYTE)Mine_OleConvertOLESTREAMToIStorageEx);
    DetourFunctionWithTrampoline((PBYTE)Real_OleCreate,
                                 (PBYTE)Mine_OleCreate);
    DetourFunctionWithTrampoline((PBYTE)Real_OleCreateDefaultHandler,
                                 (PBYTE)Mine_OleCreateDefaultHandler);
    DetourFunctionWithTrampoline((PBYTE)Real_OleCreateEmbeddingHelper,
                                 (PBYTE)Mine_OleCreateEmbeddingHelper);
    DetourFunctionWithTrampoline((PBYTE)Real_OleCreateEx,
                                 (PBYTE)Mine_OleCreateEx);
    DetourFunctionWithTrampoline((PBYTE)Real_OleCreateFromData,
                                 (PBYTE)Mine_OleCreateFromData);
    DetourFunctionWithTrampoline((PBYTE)Real_OleCreateFromDataEx,
                                 (PBYTE)Mine_OleCreateFromDataEx);
    DetourFunctionWithTrampoline((PBYTE)Real_OleCreateFromFile,
                                 (PBYTE)Mine_OleCreateFromFile);
    DetourFunctionWithTrampoline((PBYTE)Real_OleCreateFromFileEx,
                                 (PBYTE)Mine_OleCreateFromFileEx);
    DetourFunctionWithTrampoline((PBYTE)Real_OleCreateLink,
                                 (PBYTE)Mine_OleCreateLink);
    DetourFunctionWithTrampoline((PBYTE)Real_OleCreateLinkEx,
                                 (PBYTE)Mine_OleCreateLinkEx);
    DetourFunctionWithTrampoline((PBYTE)Real_OleCreateLinkFromData,
                                 (PBYTE)Mine_OleCreateLinkFromData);
    DetourFunctionWithTrampoline((PBYTE)Real_OleCreateLinkFromDataEx,
                                 (PBYTE)Mine_OleCreateLinkFromDataEx);
    DetourFunctionWithTrampoline((PBYTE)Real_OleCreateLinkToFile,
                                 (PBYTE)Mine_OleCreateLinkToFile);
    DetourFunctionWithTrampoline((PBYTE)Real_OleCreateLinkToFileEx,
                                 (PBYTE)Mine_OleCreateLinkToFileEx);
    DetourFunctionWithTrampoline((PBYTE)Real_OleCreateMenuDescriptor,
                                 (PBYTE)Mine_OleCreateMenuDescriptor);
    DetourFunctionWithTrampoline((PBYTE)Real_OleCreateStaticFromData,
                                 (PBYTE)Mine_OleCreateStaticFromData);
    DetourFunctionWithTrampoline((PBYTE)Real_OleDestroyMenuDescriptor,
                                 (PBYTE)Mine_OleDestroyMenuDescriptor);
    DetourFunctionWithTrampoline((PBYTE)Real_OleDoAutoConvert,
                                 (PBYTE)Mine_OleDoAutoConvert);
    DetourFunctionWithTrampoline((PBYTE)Real_OleDraw,
                                 (PBYTE)Mine_OleDraw);
    DetourFunctionWithTrampoline((PBYTE)Real_OleDuplicateData,
                                 (PBYTE)Mine_OleDuplicateData);
    DetourFunctionWithTrampoline((PBYTE)Real_OleFlushClipboard,
                                 (PBYTE)Mine_OleFlushClipboard);
    DetourFunctionWithTrampoline((PBYTE)Real_OleGetAutoConvert,
                                 (PBYTE)Mine_OleGetAutoConvert);
    DetourFunctionWithTrampoline((PBYTE)Real_OleGetClipboard,
                                 (PBYTE)Mine_OleGetClipboard);
    DetourFunctionWithTrampoline((PBYTE)Real_OleGetIconOfClass,
                                 (PBYTE)Mine_OleGetIconOfClass);
    DetourFunctionWithTrampoline((PBYTE)Real_OleGetIconOfFile,
                                 (PBYTE)Mine_OleGetIconOfFile);
    DetourFunctionWithTrampoline((PBYTE)Real_OleInitialize,
                                 (PBYTE)Mine_OleInitialize);
    DetourFunctionWithTrampoline((PBYTE)Real_OleIsCurrentClipboard,
                                 (PBYTE)Mine_OleIsCurrentClipboard);
    DetourFunctionWithTrampoline((PBYTE)Real_OleIsRunning,
                                 (PBYTE)Mine_OleIsRunning);
    DetourFunctionWithTrampoline((PBYTE)Real_OleLoad,
                                 (PBYTE)Mine_OleLoad);
    DetourFunctionWithTrampoline((PBYTE)Real_OleLoadFromStream,
                                 (PBYTE)Mine_OleLoadFromStream);
    DetourFunctionWithTrampoline((PBYTE)Real_OleLockRunning,
                                 (PBYTE)Mine_OleLockRunning);
    DetourFunctionWithTrampoline((PBYTE)Real_OleMetafilePictFromIconAndLabel,
                                 (PBYTE)Mine_OleMetafilePictFromIconAndLabel);
    DetourFunctionWithTrampoline((PBYTE)Real_OleNoteObjectVisible,
                                 (PBYTE)Mine_OleNoteObjectVisible);
    DetourFunctionWithTrampoline((PBYTE)Real_OleQueryCreateFromData,
                                 (PBYTE)Mine_OleQueryCreateFromData);
    DetourFunctionWithTrampoline((PBYTE)Real_OleQueryLinkFromData,
                                 (PBYTE)Mine_OleQueryLinkFromData);
    DetourFunctionWithTrampoline((PBYTE)Real_OleRegEnumFormatEtc,
                                 (PBYTE)Mine_OleRegEnumFormatEtc);
    DetourFunctionWithTrampoline((PBYTE)Real_OleRegEnumVerbs,
                                 (PBYTE)Mine_OleRegEnumVerbs);
    DetourFunctionWithTrampoline((PBYTE)Real_OleRegGetMiscStatus,
                                 (PBYTE)Mine_OleRegGetMiscStatus);
    DetourFunctionWithTrampoline((PBYTE)Real_OleRegGetUserType,
                                 (PBYTE)Mine_OleRegGetUserType);
    DetourFunctionWithTrampoline((PBYTE)Real_OleRun,
                                 (PBYTE)Mine_OleRun);
    DetourFunctionWithTrampoline((PBYTE)Real_OleSave,
                                 (PBYTE)Mine_OleSave);
    DetourFunctionWithTrampoline((PBYTE)Real_OleSaveToStream,
                                 (PBYTE)Mine_OleSaveToStream);
    DetourFunctionWithTrampoline((PBYTE)Real_OleSetAutoConvert,
                                 (PBYTE)Mine_OleSetAutoConvert);
    DetourFunctionWithTrampoline((PBYTE)Real_OleSetClipboard,
                                 (PBYTE)Mine_OleSetClipboard);
    DetourFunctionWithTrampoline((PBYTE)Real_OleSetContainedObject,
                                 (PBYTE)Mine_OleSetContainedObject);
    DetourFunctionWithTrampoline((PBYTE)Real_OleSetMenuDescriptor,
                                 (PBYTE)Mine_OleSetMenuDescriptor);
    DetourFunctionWithTrampoline((PBYTE)Real_OleTranslateAccelerator,
                                 (PBYTE)Mine_OleTranslateAccelerator);
    DetourFunctionWithTrampoline((PBYTE)Real_OleUninitialize,
                                 (PBYTE)Mine_OleUninitialize);
    DetourFunctionWithTrampoline((PBYTE)Real_OpenClipboard,
                                 (PBYTE)Mine_OpenClipboard);
    DetourFunctionWithTrampoline((PBYTE)Real_OpenDesktopA,
                                 (PBYTE)Mine_OpenDesktopA);
    DetourFunctionWithTrampoline((PBYTE)Real_OpenDesktopW,
                                 (PBYTE)Mine_OpenDesktopW);
    DetourFunctionWithTrampoline((PBYTE)Real_OpenEventA,
                                 (PBYTE)Mine_OpenEventA);
    DetourFunctionWithTrampoline((PBYTE)Real_OpenEventW,
                                 (PBYTE)Mine_OpenEventW);
    DetourFunctionWithTrampoline((PBYTE)Real_OpenFile,
                                 (PBYTE)Mine_OpenFile);
    DetourFunctionWithTrampoline((PBYTE)Real_OpenFileMappingA,
                                 (PBYTE)Mine_OpenFileMappingA);
    DetourFunctionWithTrampoline((PBYTE)Real_OpenFileMappingW,
                                 (PBYTE)Mine_OpenFileMappingW);
    DetourFunctionWithTrampoline((PBYTE)Real_OpenIcon,
                                 (PBYTE)Mine_OpenIcon);
    DetourFunctionWithTrampoline((PBYTE)Real_OpenInputDesktop,
                                 (PBYTE)Mine_OpenInputDesktop);
    DetourFunctionWithTrampoline((PBYTE)Real_OpenMutexA,
                                 (PBYTE)Mine_OpenMutexA);
    DetourFunctionWithTrampoline((PBYTE)Real_OpenMutexW,
                                 (PBYTE)Mine_OpenMutexW);
    DetourFunctionWithTrampoline((PBYTE)Real_OpenProcess,
                                 (PBYTE)Mine_OpenProcess);
    DetourFunctionWithTrampoline((PBYTE)Real_OpenSemaphoreA,
                                 (PBYTE)Mine_OpenSemaphoreA);
    DetourFunctionWithTrampoline((PBYTE)Real_OpenSemaphoreW,
                                 (PBYTE)Mine_OpenSemaphoreW);
    DetourFunctionWithTrampoline((PBYTE)Real_OpenWaitableTimerA,
                                 (PBYTE)Mine_OpenWaitableTimerA);
    DetourFunctionWithTrampoline((PBYTE)Real_OpenWaitableTimerW,
                                 (PBYTE)Mine_OpenWaitableTimerW);
    DetourFunctionWithTrampoline((PBYTE)Real_OpenWindowStationA,
                                 (PBYTE)Mine_OpenWindowStationA);
    DetourFunctionWithTrampoline((PBYTE)Real_OpenWindowStationW,
                                 (PBYTE)Mine_OpenWindowStationW);
    DetourFunctionWithTrampoline((PBYTE)Real_OutputDebugStringA,
                                 (PBYTE)Mine_OutputDebugStringA);
    DetourFunctionWithTrampoline((PBYTE)Real_OutputDebugStringW,
                                 (PBYTE)Mine_OutputDebugStringW);
    DetourFunctionWithTrampoline((PBYTE)Real_PackDDElParam,
                                 (PBYTE)Mine_PackDDElParam);
    DetourFunctionWithTrampoline((PBYTE)Real_PaintDesktop,
                                 (PBYTE)Mine_PaintDesktop);
    DetourFunctionWithTrampoline((PBYTE)Real_PaintRgn,
                                 (PBYTE)Mine_PaintRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_PatBlt,
                                 (PBYTE)Mine_PatBlt);
    DetourFunctionWithTrampoline((PBYTE)Real_PathToRegion,
                                 (PBYTE)Mine_PathToRegion);
    DetourFunctionWithTrampoline((PBYTE)Real_PeekConsoleInputA,
                                 (PBYTE)Mine_PeekConsoleInputA);
    DetourFunctionWithTrampoline((PBYTE)Real_PeekConsoleInputW,
                                 (PBYTE)Mine_PeekConsoleInputW);
    DetourFunctionWithTrampoline((PBYTE)Real_PeekMessageA,
                                 (PBYTE)Mine_PeekMessageA);
    DetourFunctionWithTrampoline((PBYTE)Real_PeekMessageW,
                                 (PBYTE)Mine_PeekMessageW);
    DetourFunctionWithTrampoline((PBYTE)Real_PeekNamedPipe,
                                 (PBYTE)Mine_PeekNamedPipe);
    DetourFunctionWithTrampoline((PBYTE)Real_Pie,
                                 (PBYTE)Mine_Pie);
    DetourFunctionWithTrampoline((PBYTE)Real_PlayEnhMetaFile,
                                 (PBYTE)Mine_PlayEnhMetaFile);
    DetourFunctionWithTrampoline((PBYTE)Real_PlayEnhMetaFileRecord,
                                 (PBYTE)Mine_PlayEnhMetaFileRecord);
    DetourFunctionWithTrampoline((PBYTE)Real_PlayMetaFile,
                                 (PBYTE)Mine_PlayMetaFile);
    DetourFunctionWithTrampoline((PBYTE)Real_PlayMetaFileRecord,
                                 (PBYTE)Mine_PlayMetaFileRecord);
    DetourFunctionWithTrampoline((PBYTE)Real_PlgBlt,
                                 (PBYTE)Mine_PlgBlt);
    DetourFunctionWithTrampoline((PBYTE)Real_PolyBezier,
                                 (PBYTE)Mine_PolyBezier);
    DetourFunctionWithTrampoline((PBYTE)Real_PolyBezierTo,
                                 (PBYTE)Mine_PolyBezierTo);
    DetourFunctionWithTrampoline((PBYTE)Real_PolyDraw,
                                 (PBYTE)Mine_PolyDraw);
    DetourFunctionWithTrampoline((PBYTE)Real_PolyPolygon,
                                 (PBYTE)Mine_PolyPolygon);
    DetourFunctionWithTrampoline((PBYTE)Real_PolyPolyline,
                                 (PBYTE)Mine_PolyPolyline);
    DetourFunctionWithTrampoline((PBYTE)Real_PolyTextOutA,
                                 (PBYTE)Mine_PolyTextOutA);
    DetourFunctionWithTrampoline((PBYTE)Real_PolyTextOutW,
                                 (PBYTE)Mine_PolyTextOutW);
    DetourFunctionWithTrampoline((PBYTE)Real_Polygon,
                                 (PBYTE)Mine_Polygon);
    DetourFunctionWithTrampoline((PBYTE)Real_Polyline,
                                 (PBYTE)Mine_Polyline);
    DetourFunctionWithTrampoline((PBYTE)Real_PolylineTo,
                                 (PBYTE)Mine_PolylineTo);
    DetourFunctionWithTrampoline((PBYTE)Real_PostMessageA,
                                 (PBYTE)Mine_PostMessageA);
    DetourFunctionWithTrampoline((PBYTE)Real_PostMessageW,
                                 (PBYTE)Mine_PostMessageW);
    DetourFunctionWithTrampoline((PBYTE)Real_PostQueuedCompletionStatus,
                                 (PBYTE)Mine_PostQueuedCompletionStatus);
    DetourFunctionWithTrampoline((PBYTE)Real_PostQuitMessage,
                                 (PBYTE)Mine_PostQuitMessage);
    DetourFunctionWithTrampoline((PBYTE)Real_PostThreadMessageA,
                                 (PBYTE)Mine_PostThreadMessageA);
    DetourFunctionWithTrampoline((PBYTE)Real_PostThreadMessageW,
                                 (PBYTE)Mine_PostThreadMessageW);
    DetourFunctionWithTrampoline((PBYTE)Real_PrepareTape,
                                 (PBYTE)Mine_PrepareTape);
    DetourFunctionWithTrampoline((PBYTE)Real_ProgIDFromCLSID,
                                 (PBYTE)Mine_ProgIDFromCLSID);
    DetourFunctionWithTrampoline((PBYTE)Real_PropStgNameToFmtId,
                                 (PBYTE)Mine_PropStgNameToFmtId);
    DetourFunctionWithTrampoline((PBYTE)Real_PropVariantClear,
                                 (PBYTE)Mine_PropVariantClear);
    DetourFunctionWithTrampoline((PBYTE)Real_PropVariantCopy,
                                 (PBYTE)Mine_PropVariantCopy);
    DetourFunctionWithTrampoline((PBYTE)Real_PtInRect,
                                 (PBYTE)Mine_PtInRect);
    DetourFunctionWithTrampoline((PBYTE)Real_PtInRegion,
                                 (PBYTE)Mine_PtInRegion);
    DetourFunctionWithTrampoline((PBYTE)Real_PtVisible,
                                 (PBYTE)Mine_PtVisible);
    DetourFunctionWithTrampoline((PBYTE)Real_PulseEvent,
                                 (PBYTE)Mine_PulseEvent);
    DetourFunctionWithTrampoline((PBYTE)Real_PurgeComm,
                                 (PBYTE)Mine_PurgeComm);
    DetourFunctionWithTrampoline((PBYTE)Real_QueryDosDeviceA,
                                 (PBYTE)Mine_QueryDosDeviceA);
    DetourFunctionWithTrampoline((PBYTE)Real_QueryDosDeviceW,
                                 (PBYTE)Mine_QueryDosDeviceW);
    DetourFunctionWithTrampoline((PBYTE)Real_QueryPerformanceCounter,
                                 (PBYTE)Mine_QueryPerformanceCounter);
    DetourFunctionWithTrampoline((PBYTE)Real_QueryPerformanceFrequency,
                                 (PBYTE)Mine_QueryPerformanceFrequency);
    DetourFunctionWithTrampoline((PBYTE)Real_QueueUserAPC,
                                 (PBYTE)Mine_QueueUserAPC);
    DetourFunctionWithTrampoline((PBYTE)Real_RaiseException,
                                 (PBYTE)Mine_RaiseException);
    DetourFunctionWithTrampoline((PBYTE)Real_ReadClassStg,
                                 (PBYTE)Mine_ReadClassStg);
    DetourFunctionWithTrampoline((PBYTE)Real_ReadClassStm,
                                 (PBYTE)Mine_ReadClassStm);
    DetourFunctionWithTrampoline((PBYTE)Real_ReadConsoleA,
                                 (PBYTE)Mine_ReadConsoleA);
    DetourFunctionWithTrampoline((PBYTE)Real_ReadConsoleInputA,
                                 (PBYTE)Mine_ReadConsoleInputA);
    DetourFunctionWithTrampoline((PBYTE)Real_ReadConsoleInputW,
                                 (PBYTE)Mine_ReadConsoleInputW);
    DetourFunctionWithTrampoline((PBYTE)Real_ReadConsoleOutputA,
                                 (PBYTE)Mine_ReadConsoleOutputA);
    DetourFunctionWithTrampoline((PBYTE)Real_ReadConsoleOutputAttribute,
                                 (PBYTE)Mine_ReadConsoleOutputAttribute);
    DetourFunctionWithTrampoline((PBYTE)Real_ReadConsoleOutputCharacterA,
                                 (PBYTE)Mine_ReadConsoleOutputCharacterA);
    DetourFunctionWithTrampoline((PBYTE)Real_ReadConsoleOutputCharacterW,
                                 (PBYTE)Mine_ReadConsoleOutputCharacterW);
    DetourFunctionWithTrampoline((PBYTE)Real_ReadConsoleOutputW,
                                 (PBYTE)Mine_ReadConsoleOutputW);
    DetourFunctionWithTrampoline((PBYTE)Real_ReadConsoleW,
                                 (PBYTE)Mine_ReadConsoleW);
    DetourFunctionWithTrampoline((PBYTE)Real_ReadDirectoryChangesW,
                                 (PBYTE)Mine_ReadDirectoryChangesW);
    DetourFunctionWithTrampoline((PBYTE)Real_ReadFile,
                                 (PBYTE)Mine_ReadFile);
    DetourFunctionWithTrampoline((PBYTE)Real_ReadFileEx,
                                 (PBYTE)Mine_ReadFileEx);
    DetourFunctionWithTrampoline((PBYTE)Real_ReadFmtUserTypeStg,
                                 (PBYTE)Mine_ReadFmtUserTypeStg);
    DetourFunctionWithTrampoline((PBYTE)Real_ReadProcessMemory,
                                 (PBYTE)Mine_ReadProcessMemory);
    DetourFunctionWithTrampoline((PBYTE)Real_RealizePalette,
                                 (PBYTE)Mine_RealizePalette);
    DetourFunctionWithTrampoline((PBYTE)Real_RectInRegion,
                                 (PBYTE)Mine_RectInRegion);
    DetourFunctionWithTrampoline((PBYTE)Real_RectVisible,
                                 (PBYTE)Mine_RectVisible);
    DetourFunctionWithTrampoline((PBYTE)Real_Rectangle,
                                 (PBYTE)Mine_Rectangle);
    DetourFunctionWithTrampoline((PBYTE)Real_RedrawWindow,
                                 (PBYTE)Mine_RedrawWindow);
    DetourFunctionWithTrampoline((PBYTE)Real_RegisterClassA,
                                 (PBYTE)Mine_RegisterClassA);
    DetourFunctionWithTrampoline((PBYTE)Real_RegisterClassExA,
                                 (PBYTE)Mine_RegisterClassExA);
    DetourFunctionWithTrampoline((PBYTE)Real_RegisterClassExW,
                                 (PBYTE)Mine_RegisterClassExW);
    DetourFunctionWithTrampoline((PBYTE)Real_RegisterClassW,
                                 (PBYTE)Mine_RegisterClassW);
    DetourFunctionWithTrampoline((PBYTE)Real_RegisterClipboardFormatA,
                                 (PBYTE)Mine_RegisterClipboardFormatA);
    DetourFunctionWithTrampoline((PBYTE)Real_RegisterClipboardFormatW,
                                 (PBYTE)Mine_RegisterClipboardFormatW);
    DetourFunctionWithTrampoline((PBYTE)Real_RegisterDragDrop,
                                 (PBYTE)Mine_RegisterDragDrop);
    DetourFunctionWithTrampoline((PBYTE)Real_RegisterHotKey,
                                 (PBYTE)Mine_RegisterHotKey);
    DetourFunctionWithTrampoline((PBYTE)Real_RegisterWindowMessageA,
                                 (PBYTE)Mine_RegisterWindowMessageA);
    DetourFunctionWithTrampoline((PBYTE)Real_RegisterWindowMessageW,
                                 (PBYTE)Mine_RegisterWindowMessageW);
    DetourFunctionWithTrampoline((PBYTE)Real_ReleaseCapture,
                                 (PBYTE)Mine_ReleaseCapture);
    DetourFunctionWithTrampoline((PBYTE)Real_ReleaseDC,
                                 (PBYTE)Mine_ReleaseDC);
    DetourFunctionWithTrampoline((PBYTE)Real_ReleaseMutex,
                                 (PBYTE)Mine_ReleaseMutex);
    DetourFunctionWithTrampoline((PBYTE)Real_ReleaseSemaphore,
                                 (PBYTE)Mine_ReleaseSemaphore);
    DetourFunctionWithTrampoline((PBYTE)Real_ReleaseStgMedium,
                                 (PBYTE)Mine_ReleaseStgMedium);
    DetourFunctionWithTrampoline((PBYTE)Real_RemoveDirectoryA,
                                 (PBYTE)Mine_RemoveDirectoryA);
    DetourFunctionWithTrampoline((PBYTE)Real_RemoveDirectoryW,
                                 (PBYTE)Mine_RemoveDirectoryW);
    DetourFunctionWithTrampoline((PBYTE)Real_RemoveFontResourceA,
                                 (PBYTE)Mine_RemoveFontResourceA);
    DetourFunctionWithTrampoline((PBYTE)Real_RemoveFontResourceW,
                                 (PBYTE)Mine_RemoveFontResourceW);
    DetourFunctionWithTrampoline((PBYTE)Real_RemoveMenu,
                                 (PBYTE)Mine_RemoveMenu);
    DetourFunctionWithTrampoline((PBYTE)Real_RemovePropA,
                                 (PBYTE)Mine_RemovePropA);
    DetourFunctionWithTrampoline((PBYTE)Real_RemovePropW,
                                 (PBYTE)Mine_RemovePropW);
    DetourFunctionWithTrampoline((PBYTE)Real_ReplyMessage,
                                 (PBYTE)Mine_ReplyMessage);
    DetourFunctionWithTrampoline((PBYTE)Real_ResetDCA,
                                 (PBYTE)Mine_ResetDCA);
    DetourFunctionWithTrampoline((PBYTE)Real_ResetDCW,
                                 (PBYTE)Mine_ResetDCW);
    DetourFunctionWithTrampoline((PBYTE)Real_ResetEvent,
                                 (PBYTE)Mine_ResetEvent);
    DetourFunctionWithTrampoline((PBYTE)Real_ResizePalette,
                                 (PBYTE)Mine_ResizePalette);
    DetourFunctionWithTrampoline((PBYTE)Real_RestoreDC,
                                 (PBYTE)Mine_RestoreDC);
    DetourFunctionWithTrampoline((PBYTE)Real_ResumeThread,
                                 (PBYTE)Mine_ResumeThread);
    DetourFunctionWithTrampoline((PBYTE)Real_ReuseDDElParam,
                                 (PBYTE)Mine_ReuseDDElParam);
    DetourFunctionWithTrampoline((PBYTE)Real_RevokeDragDrop,
                                 (PBYTE)Mine_RevokeDragDrop);
    DetourFunctionWithTrampoline((PBYTE)Real_RoundRect,
                                 (PBYTE)Mine_RoundRect);
    DetourFunctionWithTrampoline((PBYTE)Real_SaveDC,
                                 (PBYTE)Mine_SaveDC);
    DetourFunctionWithTrampoline((PBYTE)Real_ScaleViewportExtEx,
                                 (PBYTE)Mine_ScaleViewportExtEx);
    DetourFunctionWithTrampoline((PBYTE)Real_ScaleWindowExtEx,
                                 (PBYTE)Mine_ScaleWindowExtEx);
    DetourFunctionWithTrampoline((PBYTE)Real_ScreenToClient,
                                 (PBYTE)Mine_ScreenToClient);
    DetourFunctionWithTrampoline((PBYTE)Real_ScrollConsoleScreenBufferA,
                                 (PBYTE)Mine_ScrollConsoleScreenBufferA);
    DetourFunctionWithTrampoline((PBYTE)Real_ScrollConsoleScreenBufferW,
                                 (PBYTE)Mine_ScrollConsoleScreenBufferW);
    DetourFunctionWithTrampoline((PBYTE)Real_ScrollDC,
                                 (PBYTE)Mine_ScrollDC);
    DetourFunctionWithTrampoline((PBYTE)Real_ScrollWindow,
                                 (PBYTE)Mine_ScrollWindow);
    DetourFunctionWithTrampoline((PBYTE)Real_ScrollWindowEx,
                                 (PBYTE)Mine_ScrollWindowEx);
    DetourFunctionWithTrampoline((PBYTE)Real_SearchPathA,
                                 (PBYTE)Mine_SearchPathA);
    DetourFunctionWithTrampoline((PBYTE)Real_SearchPathW,
                                 (PBYTE)Mine_SearchPathW);
    DetourFunctionWithTrampoline((PBYTE)Real_SelectClipPath,
                                 (PBYTE)Mine_SelectClipPath);
    DetourFunctionWithTrampoline((PBYTE)Real_SelectClipRgn,
                                 (PBYTE)Mine_SelectClipRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_SelectObject,
                                 (PBYTE)Mine_SelectObject);
    DetourFunctionWithTrampoline((PBYTE)Real_SelectPalette,
                                 (PBYTE)Mine_SelectPalette);
    DetourFunctionWithTrampoline((PBYTE)Real_SendDlgItemMessageA,
                                 (PBYTE)Mine_SendDlgItemMessageA);
    DetourFunctionWithTrampoline((PBYTE)Real_SendDlgItemMessageW,
                                 (PBYTE)Mine_SendDlgItemMessageW);
    DetourFunctionWithTrampoline((PBYTE)Real_SendMessageA,
                                 (PBYTE)Mine_SendMessageA);
    DetourFunctionWithTrampoline((PBYTE)Real_SendMessageCallbackA,
                                 (PBYTE)Mine_SendMessageCallbackA);
    DetourFunctionWithTrampoline((PBYTE)Real_SendMessageCallbackW,
                                 (PBYTE)Mine_SendMessageCallbackW);
    DetourFunctionWithTrampoline((PBYTE)Real_SendMessageTimeoutA,
                                 (PBYTE)Mine_SendMessageTimeoutA);
    DetourFunctionWithTrampoline((PBYTE)Real_SendMessageTimeoutW,
                                 (PBYTE)Mine_SendMessageTimeoutW);
    DetourFunctionWithTrampoline((PBYTE)Real_SendMessageW,
                                 (PBYTE)Mine_SendMessageW);
    DetourFunctionWithTrampoline((PBYTE)Real_SendNotifyMessageA,
                                 (PBYTE)Mine_SendNotifyMessageA);
    DetourFunctionWithTrampoline((PBYTE)Real_SendNotifyMessageW,
                                 (PBYTE)Mine_SendNotifyMessageW);
    DetourFunctionWithTrampoline((PBYTE)Real_SetAbortProc,
                                 (PBYTE)Mine_SetAbortProc);
    DetourFunctionWithTrampoline((PBYTE)Real_SetActiveWindow,
                                 (PBYTE)Mine_SetActiveWindow);
    DetourFunctionWithTrampoline((PBYTE)Real_SetArcDirection,
                                 (PBYTE)Mine_SetArcDirection);
    DetourFunctionWithTrampoline((PBYTE)Real_SetBitmapBits,
                                 (PBYTE)Mine_SetBitmapBits);
    DetourFunctionWithTrampoline((PBYTE)Real_SetBitmapDimensionEx,
                                 (PBYTE)Mine_SetBitmapDimensionEx);
    DetourFunctionWithTrampoline((PBYTE)Real_SetBkColor,
                                 (PBYTE)Mine_SetBkColor);
    DetourFunctionWithTrampoline((PBYTE)Real_SetBkMode,
                                 (PBYTE)Mine_SetBkMode);
    DetourFunctionWithTrampoline((PBYTE)Real_SetBoundsRect,
                                 (PBYTE)Mine_SetBoundsRect);
    DetourFunctionWithTrampoline((PBYTE)Real_SetBrushOrgEx,
                                 (PBYTE)Mine_SetBrushOrgEx);
    DetourFunctionWithTrampoline((PBYTE)Real_SetCapture,
                                 (PBYTE)Mine_SetCapture);
    DetourFunctionWithTrampoline((PBYTE)Real_SetCaretBlinkTime,
                                 (PBYTE)Mine_SetCaretBlinkTime);
    DetourFunctionWithTrampoline((PBYTE)Real_SetCaretPos,
                                 (PBYTE)Mine_SetCaretPos);
    DetourFunctionWithTrampoline((PBYTE)Real_SetClassLongA,
                                 (PBYTE)Mine_SetClassLongA);
    DetourFunctionWithTrampoline((PBYTE)Real_SetClassLongW,
                                 (PBYTE)Mine_SetClassLongW);
    DetourFunctionWithTrampoline((PBYTE)Real_SetClassWord,
                                 (PBYTE)Mine_SetClassWord);
    DetourFunctionWithTrampoline((PBYTE)Real_SetClipboardData,
                                 (PBYTE)Mine_SetClipboardData);
    DetourFunctionWithTrampoline((PBYTE)Real_SetClipboardViewer,
                                 (PBYTE)Mine_SetClipboardViewer);
    DetourFunctionWithTrampoline((PBYTE)Real_SetColorAdjustment,
                                 (PBYTE)Mine_SetColorAdjustment);
    DetourFunctionWithTrampoline((PBYTE)Real_SetColorSpace,
                                 (PBYTE)Mine_SetColorSpace);
    DetourFunctionWithTrampoline((PBYTE)Real_SetCommBreak,
                                 (PBYTE)Mine_SetCommBreak);
    DetourFunctionWithTrampoline((PBYTE)Real_SetCommConfig,
                                 (PBYTE)Mine_SetCommConfig);
    DetourFunctionWithTrampoline((PBYTE)Real_SetCommMask,
                                 (PBYTE)Mine_SetCommMask);
    DetourFunctionWithTrampoline((PBYTE)Real_SetCommState,
                                 (PBYTE)Mine_SetCommState);
    DetourFunctionWithTrampoline((PBYTE)Real_SetCommTimeouts,
                                 (PBYTE)Mine_SetCommTimeouts);
    DetourFunctionWithTrampoline((PBYTE)Real_SetComputerNameA,
                                 (PBYTE)Mine_SetComputerNameA);
    DetourFunctionWithTrampoline((PBYTE)Real_SetComputerNameW,
                                 (PBYTE)Mine_SetComputerNameW);
    DetourFunctionWithTrampoline((PBYTE)Real_SetConsoleActiveScreenBuffer,
                                 (PBYTE)Mine_SetConsoleActiveScreenBuffer);
    DetourFunctionWithTrampoline((PBYTE)Real_SetConsoleCP,
                                 (PBYTE)Mine_SetConsoleCP);
    DetourFunctionWithTrampoline((PBYTE)Real_SetConsoleCtrlHandler,
                                 (PBYTE)Mine_SetConsoleCtrlHandler);
    DetourFunctionWithTrampoline((PBYTE)Real_SetConsoleCursorInfo,
                                 (PBYTE)Mine_SetConsoleCursorInfo);
    DetourFunctionWithTrampoline((PBYTE)Real_SetConsoleCursorPosition,
                                 (PBYTE)Mine_SetConsoleCursorPosition);
    DetourFunctionWithTrampoline((PBYTE)Real_SetConsoleMode,
                                 (PBYTE)Mine_SetConsoleMode);
    DetourFunctionWithTrampoline((PBYTE)Real_SetConsoleOutputCP,
                                 (PBYTE)Mine_SetConsoleOutputCP);
    DetourFunctionWithTrampoline((PBYTE)Real_SetConsoleScreenBufferSize,
                                 (PBYTE)Mine_SetConsoleScreenBufferSize);
    DetourFunctionWithTrampoline((PBYTE)Real_SetConsoleTextAttribute,
                                 (PBYTE)Mine_SetConsoleTextAttribute);
    DetourFunctionWithTrampoline((PBYTE)Real_SetConsoleTitleA,
                                 (PBYTE)Mine_SetConsoleTitleA);
    DetourFunctionWithTrampoline((PBYTE)Real_SetConsoleTitleW,
                                 (PBYTE)Mine_SetConsoleTitleW);
    DetourFunctionWithTrampoline((PBYTE)Real_SetConsoleWindowInfo,
                                 (PBYTE)Mine_SetConsoleWindowInfo);
    DetourFunctionWithTrampoline((PBYTE)Real_SetConvertStg,
                                 (PBYTE)Mine_SetConvertStg);
    DetourFunctionWithTrampoline((PBYTE)Real_SetCurrentDirectoryA,
                                 (PBYTE)Mine_SetCurrentDirectoryA);
    DetourFunctionWithTrampoline((PBYTE)Real_SetCurrentDirectoryW,
                                 (PBYTE)Mine_SetCurrentDirectoryW);
    DetourFunctionWithTrampoline((PBYTE)Real_SetCursor,
                                 (PBYTE)Mine_SetCursor);
    DetourFunctionWithTrampoline((PBYTE)Real_SetCursorPos,
                                 (PBYTE)Mine_SetCursorPos);
    DetourFunctionWithTrampoline((PBYTE)Real_SetDIBColorTable,
                                 (PBYTE)Mine_SetDIBColorTable);
    DetourFunctionWithTrampoline((PBYTE)Real_SetDIBits,
                                 (PBYTE)Mine_SetDIBits);
    DetourFunctionWithTrampoline((PBYTE)Real_SetDIBitsToDevice,
                                 (PBYTE)Mine_SetDIBitsToDevice);
    DetourFunctionWithTrampoline((PBYTE)Real_SetDebugErrorLevel,
                                 (PBYTE)Mine_SetDebugErrorLevel);
    DetourFunctionWithTrampoline((PBYTE)Real_SetDefaultCommConfigA,
                                 (PBYTE)Mine_SetDefaultCommConfigA);
    DetourFunctionWithTrampoline((PBYTE)Real_SetDefaultCommConfigW,
                                 (PBYTE)Mine_SetDefaultCommConfigW);
    DetourFunctionWithTrampoline((PBYTE)Real_SetDeviceGammaRamp,
                                 (PBYTE)Mine_SetDeviceGammaRamp);
    DetourFunctionWithTrampoline((PBYTE)Real_SetDlgItemInt,
                                 (PBYTE)Mine_SetDlgItemInt);
    DetourFunctionWithTrampoline((PBYTE)Real_SetDlgItemTextA,
                                 (PBYTE)Mine_SetDlgItemTextA);
    DetourFunctionWithTrampoline((PBYTE)Real_SetDlgItemTextW,
                                 (PBYTE)Mine_SetDlgItemTextW);
    DetourFunctionWithTrampoline((PBYTE)Real_SetDoubleClickTime,
                                 (PBYTE)Mine_SetDoubleClickTime);
    DetourFunctionWithTrampoline((PBYTE)Real_SetEndOfFile,
                                 (PBYTE)Mine_SetEndOfFile);
    DetourFunctionWithTrampoline((PBYTE)Real_SetEnhMetaFileBits,
                                 (PBYTE)Mine_SetEnhMetaFileBits);
    DetourFunctionWithTrampoline((PBYTE)Real_SetEnvironmentVariableA,
                                 (PBYTE)Mine_SetEnvironmentVariableA);
    DetourFunctionWithTrampoline((PBYTE)Real_SetEnvironmentVariableW,
                                 (PBYTE)Mine_SetEnvironmentVariableW);
    DetourFunctionWithTrampoline((PBYTE)Real_SetErrorMode,
                                 (PBYTE)Mine_SetErrorMode);
    DetourFunctionWithTrampoline((PBYTE)Real_SetEvent,
                                 (PBYTE)Mine_SetEvent);
    DetourFunctionWithTrampoline((PBYTE)Real_SetFileApisToANSI,
                                 (PBYTE)Mine_SetFileApisToANSI);
    DetourFunctionWithTrampoline((PBYTE)Real_SetFileApisToOEM,
                                 (PBYTE)Mine_SetFileApisToOEM);
    DetourFunctionWithTrampoline((PBYTE)Real_SetFileAttributesA,
                                 (PBYTE)Mine_SetFileAttributesA);
    DetourFunctionWithTrampoline((PBYTE)Real_SetFileAttributesW,
                                 (PBYTE)Mine_SetFileAttributesW);
    DetourFunctionWithTrampoline((PBYTE)Real_SetFilePointer,
                                 (PBYTE)Mine_SetFilePointer);
    DetourFunctionWithTrampoline((PBYTE)Real_SetFileTime,
                                 (PBYTE)Mine_SetFileTime);
    DetourFunctionWithTrampoline((PBYTE)Real_SetFocus,
                                 (PBYTE)Mine_SetFocus);
    DetourFunctionWithTrampoline((PBYTE)Real_SetForegroundWindow,
                                 (PBYTE)Mine_SetForegroundWindow);
    DetourFunctionWithTrampoline((PBYTE)Real_SetGraphicsMode,
                                 (PBYTE)Mine_SetGraphicsMode);
    DetourFunctionWithTrampoline((PBYTE)Real_SetHandleCount,
                                 (PBYTE)Mine_SetHandleCount);
    DetourFunctionWithTrampoline((PBYTE)Real_SetHandleInformation,
                                 (PBYTE)Mine_SetHandleInformation);
    DetourFunctionWithTrampoline((PBYTE)Real_SetICMMode,
                                 (PBYTE)Mine_SetICMMode);
    DetourFunctionWithTrampoline((PBYTE)Real_SetICMProfileA,
                                 (PBYTE)Mine_SetICMProfileA);
    DetourFunctionWithTrampoline((PBYTE)Real_SetICMProfileW,
                                 (PBYTE)Mine_SetICMProfileW);
    DetourFunctionWithTrampoline((PBYTE)Real_SetKeyboardState,
                                 (PBYTE)Mine_SetKeyboardState);
    DetourFunctionWithTrampoline((PBYTE)Real_SetLocalTime,
                                 (PBYTE)Mine_SetLocalTime);
    DetourFunctionWithTrampoline((PBYTE)Real_SetLocaleInfoA,
                                 (PBYTE)Mine_SetLocaleInfoA);
    DetourFunctionWithTrampoline((PBYTE)Real_SetLocaleInfoW,
                                 (PBYTE)Mine_SetLocaleInfoW);
    DetourFunctionWithTrampoline((PBYTE)Real_SetMailslotInfo,
                                 (PBYTE)Mine_SetMailslotInfo);
    DetourFunctionWithTrampoline((PBYTE)Real_SetMapMode,
                                 (PBYTE)Mine_SetMapMode);
    DetourFunctionWithTrampoline((PBYTE)Real_SetMapperFlags,
                                 (PBYTE)Mine_SetMapperFlags);
    DetourFunctionWithTrampoline((PBYTE)Real_SetMenu,
                                 (PBYTE)Mine_SetMenu);
    DetourFunctionWithTrampoline((PBYTE)Real_SetMenuContextHelpId,
                                 (PBYTE)Mine_SetMenuContextHelpId);
    DetourFunctionWithTrampoline((PBYTE)Real_SetMenuDefaultItem,
                                 (PBYTE)Mine_SetMenuDefaultItem);
    DetourFunctionWithTrampoline((PBYTE)Real_SetMenuItemBitmaps,
                                 (PBYTE)Mine_SetMenuItemBitmaps);
    DetourFunctionWithTrampoline((PBYTE)Real_SetMenuItemInfoA,
                                 (PBYTE)Mine_SetMenuItemInfoA);
    DetourFunctionWithTrampoline((PBYTE)Real_SetMenuItemInfoW,
                                 (PBYTE)Mine_SetMenuItemInfoW);
    DetourFunctionWithTrampoline((PBYTE)Real_SetMessageExtraInfo,
                                 (PBYTE)Mine_SetMessageExtraInfo);
    DetourFunctionWithTrampoline((PBYTE)Real_SetMessageQueue,
                                 (PBYTE)Mine_SetMessageQueue);
    DetourFunctionWithTrampoline((PBYTE)Real_SetMetaFileBitsEx,
                                 (PBYTE)Mine_SetMetaFileBitsEx);
    DetourFunctionWithTrampoline((PBYTE)Real_SetMetaRgn,
                                 (PBYTE)Mine_SetMetaRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_SetMiterLimit,
                                 (PBYTE)Mine_SetMiterLimit);
    DetourFunctionWithTrampoline((PBYTE)Real_SetNamedPipeHandleState,
                                 (PBYTE)Mine_SetNamedPipeHandleState);
    DetourFunctionWithTrampoline((PBYTE)Real_SetPaletteEntries,
                                 (PBYTE)Mine_SetPaletteEntries);
    DetourFunctionWithTrampoline((PBYTE)Real_SetParent,
                                 (PBYTE)Mine_SetParent);
    DetourFunctionWithTrampoline((PBYTE)Real_SetPixel,
                                 (PBYTE)Mine_SetPixel);
    DetourFunctionWithTrampoline((PBYTE)Real_SetPixelFormat,
                                 (PBYTE)Mine_SetPixelFormat);
    DetourFunctionWithTrampoline((PBYTE)Real_SetPixelV,
                                 (PBYTE)Mine_SetPixelV);
    DetourFunctionWithTrampoline((PBYTE)Real_SetPolyFillMode,
                                 (PBYTE)Mine_SetPolyFillMode);
    DetourFunctionWithTrampoline((PBYTE)Real_SetPriorityClass,
                                 (PBYTE)Mine_SetPriorityClass);
    DetourFunctionWithTrampoline((PBYTE)Real_SetProcessAffinityMask,
                                 (PBYTE)Mine_SetProcessAffinityMask);
    DetourFunctionWithTrampoline((PBYTE)Real_SetProcessPriorityBoost,
                                 (PBYTE)Mine_SetProcessPriorityBoost);
    DetourFunctionWithTrampoline((PBYTE)Real_SetProcessShutdownParameters,
                                 (PBYTE)Mine_SetProcessShutdownParameters);
    DetourFunctionWithTrampoline((PBYTE)Real_SetProcessWindowStation,
                                 (PBYTE)Mine_SetProcessWindowStation);
    DetourFunctionWithTrampoline((PBYTE)Real_SetProcessWorkingSetSize,
                                 (PBYTE)Mine_SetProcessWorkingSetSize);
    DetourFunctionWithTrampoline((PBYTE)Real_SetPropA,
                                 (PBYTE)Mine_SetPropA);
    DetourFunctionWithTrampoline((PBYTE)Real_SetPropW,
                                 (PBYTE)Mine_SetPropW);
    DetourFunctionWithTrampoline((PBYTE)Real_SetROP2,
                                 (PBYTE)Mine_SetROP2);
    DetourFunctionWithTrampoline((PBYTE)Real_SetRect,
                                 (PBYTE)Mine_SetRect);
    DetourFunctionWithTrampoline((PBYTE)Real_SetRectEmpty,
                                 (PBYTE)Mine_SetRectEmpty);
    DetourFunctionWithTrampoline((PBYTE)Real_SetRectRgn,
                                 (PBYTE)Mine_SetRectRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_SetScrollInfo,
                                 (PBYTE)Mine_SetScrollInfo);
    DetourFunctionWithTrampoline((PBYTE)Real_SetScrollPos,
                                 (PBYTE)Mine_SetScrollPos);
    DetourFunctionWithTrampoline((PBYTE)Real_SetScrollRange,
                                 (PBYTE)Mine_SetScrollRange);
    DetourFunctionWithTrampoline((PBYTE)Real_SetStdHandle,
                                 (PBYTE)Mine_SetStdHandle);
    DetourFunctionWithTrampoline((PBYTE)Real_SetStretchBltMode,
                                 (PBYTE)Mine_SetStretchBltMode);
    DetourFunctionWithTrampoline((PBYTE)Real_SetSysColors,
                                 (PBYTE)Mine_SetSysColors);
    DetourFunctionWithTrampoline((PBYTE)Real_SetSystemCursor,
                                 (PBYTE)Mine_SetSystemCursor);
    DetourFunctionWithTrampoline((PBYTE)Real_SetSystemPaletteUse,
                                 (PBYTE)Mine_SetSystemPaletteUse);
    DetourFunctionWithTrampoline((PBYTE)Real_SetSystemPowerState,
                                 (PBYTE)Mine_SetSystemPowerState);
    DetourFunctionWithTrampoline((PBYTE)Real_SetSystemTime,
                                 (PBYTE)Mine_SetSystemTime);
    DetourFunctionWithTrampoline((PBYTE)Real_SetSystemTimeAdjustment,
                                 (PBYTE)Mine_SetSystemTimeAdjustment);
    DetourFunctionWithTrampoline((PBYTE)Real_SetTapeParameters,
                                 (PBYTE)Mine_SetTapeParameters);
    DetourFunctionWithTrampoline((PBYTE)Real_SetTapePosition,
                                 (PBYTE)Mine_SetTapePosition);
    DetourFunctionWithTrampoline((PBYTE)Real_SetTextAlign,
                                 (PBYTE)Mine_SetTextAlign);
    DetourFunctionWithTrampoline((PBYTE)Real_SetTextCharacterExtra,
                                 (PBYTE)Mine_SetTextCharacterExtra);
    DetourFunctionWithTrampoline((PBYTE)Real_SetTextColor,
                                 (PBYTE)Mine_SetTextColor);
    DetourFunctionWithTrampoline((PBYTE)Real_SetTextJustification,
                                 (PBYTE)Mine_SetTextJustification);
    DetourFunctionWithTrampoline((PBYTE)Real_SetThreadAffinityMask,
                                 (PBYTE)Mine_SetThreadAffinityMask);
    DetourFunctionWithTrampoline((PBYTE)Real_SetThreadContext,
                                 (PBYTE)Mine_SetThreadContext);
    DetourFunctionWithTrampoline((PBYTE)Real_SetThreadDesktop,
                                 (PBYTE)Mine_SetThreadDesktop);
    DetourFunctionWithTrampoline((PBYTE)Real_SetThreadIdealProcessor,
                                 (PBYTE)Mine_SetThreadIdealProcessor);
    DetourFunctionWithTrampoline((PBYTE)Real_SetThreadLocale,
                                 (PBYTE)Mine_SetThreadLocale);
    DetourFunctionWithTrampoline((PBYTE)Real_SetThreadPriority,
                                 (PBYTE)Mine_SetThreadPriority);
    DetourFunctionWithTrampoline((PBYTE)Real_SetThreadPriorityBoost,
                                 (PBYTE)Mine_SetThreadPriorityBoost);
    DetourFunctionWithTrampoline((PBYTE)Real_SetTimeZoneInformation,
                                 (PBYTE)Mine_SetTimeZoneInformation);
    DetourFunctionWithTrampoline((PBYTE)Real_SetTimer,
                                 (PBYTE)Mine_SetTimer);
    DetourFunctionWithTrampoline((PBYTE)Real_SetUnhandledExceptionFilter,
                                 (PBYTE)Mine_SetUnhandledExceptionFilter);
    DetourFunctionWithTrampoline((PBYTE)Real_SetUserObjectInformationA,
                                 (PBYTE)Mine_SetUserObjectInformationA);
    DetourFunctionWithTrampoline((PBYTE)Real_SetUserObjectInformationW,
                                 (PBYTE)Mine_SetUserObjectInformationW);
    DetourFunctionWithTrampoline((PBYTE)Real_SetUserObjectSecurity,
                                 (PBYTE)Mine_SetUserObjectSecurity);
    DetourFunctionWithTrampoline((PBYTE)Real_SetViewportExtEx,
                                 (PBYTE)Mine_SetViewportExtEx);
    DetourFunctionWithTrampoline((PBYTE)Real_SetViewportOrgEx,
                                 (PBYTE)Mine_SetViewportOrgEx);
    DetourFunctionWithTrampoline((PBYTE)Real_SetVolumeLabelA,
                                 (PBYTE)Mine_SetVolumeLabelA);
    DetourFunctionWithTrampoline((PBYTE)Real_SetVolumeLabelW,
                                 (PBYTE)Mine_SetVolumeLabelW);
    DetourFunctionWithTrampoline((PBYTE)Real_SetWaitableTimer,
                                 (PBYTE)Mine_SetWaitableTimer);
    DetourFunctionWithTrampoline((PBYTE)Real_SetWinMetaFileBits,
                                 (PBYTE)Mine_SetWinMetaFileBits);
    DetourFunctionWithTrampoline((PBYTE)Real_SetWindowContextHelpId,
                                 (PBYTE)Mine_SetWindowContextHelpId);
    DetourFunctionWithTrampoline((PBYTE)Real_SetWindowExtEx,
                                 (PBYTE)Mine_SetWindowExtEx);
    DetourFunctionWithTrampoline((PBYTE)Real_SetWindowLongA,
                                 (PBYTE)Mine_SetWindowLongA);
    DetourFunctionWithTrampoline((PBYTE)Real_SetWindowLongW,
                                 (PBYTE)Mine_SetWindowLongW);
    DetourFunctionWithTrampoline((PBYTE)Real_SetWindowOrgEx,
                                 (PBYTE)Mine_SetWindowOrgEx);
    DetourFunctionWithTrampoline((PBYTE)Real_SetWindowPlacement,
                                 (PBYTE)Mine_SetWindowPlacement);
    DetourFunctionWithTrampoline((PBYTE)Real_SetWindowPos,
                                 (PBYTE)Mine_SetWindowPos);
    DetourFunctionWithTrampoline((PBYTE)Real_SetWindowRgn,
                                 (PBYTE)Mine_SetWindowRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_SetWindowTextA,
                                 (PBYTE)Mine_SetWindowTextA);
    DetourFunctionWithTrampoline((PBYTE)Real_SetWindowTextW,
                                 (PBYTE)Mine_SetWindowTextW);
    DetourFunctionWithTrampoline((PBYTE)Real_SetWindowWord,
                                 (PBYTE)Mine_SetWindowWord);
    DetourFunctionWithTrampoline((PBYTE)Real_SetWindowsHookA,
                                 (PBYTE)Mine_SetWindowsHookA);
    DetourFunctionWithTrampoline((PBYTE)Real_SetWindowsHookExA,
                                 (PBYTE)Mine_SetWindowsHookExA);
    DetourFunctionWithTrampoline((PBYTE)Real_SetWindowsHookExW,
                                 (PBYTE)Mine_SetWindowsHookExW);
    DetourFunctionWithTrampoline((PBYTE)Real_SetWindowsHookW,
                                 (PBYTE)Mine_SetWindowsHookW);
    DetourFunctionWithTrampoline((PBYTE)Real_SetWorldTransform,
                                 (PBYTE)Mine_SetWorldTransform);
    DetourFunctionWithTrampoline((PBYTE)Real_SetupComm,
                                 (PBYTE)Mine_SetupComm);
    DetourFunctionWithTrampoline((PBYTE)Real_ShowCaret,
                                 (PBYTE)Mine_ShowCaret);
    DetourFunctionWithTrampoline((PBYTE)Real_ShowCursor,
                                 (PBYTE)Mine_ShowCursor);
    DetourFunctionWithTrampoline((PBYTE)Real_ShowOwnedPopups,
                                 (PBYTE)Mine_ShowOwnedPopups);
    DetourFunctionWithTrampoline((PBYTE)Real_ShowScrollBar,
                                 (PBYTE)Mine_ShowScrollBar);
    DetourFunctionWithTrampoline((PBYTE)Real_ShowWindow,
                                 (PBYTE)Mine_ShowWindow);
    DetourFunctionWithTrampoline((PBYTE)Real_ShowWindowAsync,
                                 (PBYTE)Mine_ShowWindowAsync);
    DetourFunctionWithTrampoline((PBYTE)Real_SignalObjectAndWait,
                                 (PBYTE)Mine_SignalObjectAndWait);
    DetourFunctionWithTrampoline((PBYTE)Real_SizeofResource,
                                 (PBYTE)Mine_SizeofResource);
    DetourFunctionWithTrampoline((PBYTE)Real_Sleep,
                                 (PBYTE)Mine_Sleep);
    DetourFunctionWithTrampoline((PBYTE)Real_SleepEx,
                                 (PBYTE)Mine_SleepEx);
    DetourFunctionWithTrampoline((PBYTE)Real_StartDocA,
                                 (PBYTE)Mine_StartDocA);
    DetourFunctionWithTrampoline((PBYTE)Real_StartDocW,
                                 (PBYTE)Mine_StartDocW);
    DetourFunctionWithTrampoline((PBYTE)Real_StartPage,
                                 (PBYTE)Mine_StartPage);
    DetourFunctionWithTrampoline((PBYTE)Real_StgCreateDocfile,
                                 (PBYTE)Mine_StgCreateDocfile);
    DetourFunctionWithTrampoline((PBYTE)Real_StgCreateDocfileOnILockBytes,
                                 (PBYTE)Mine_StgCreateDocfileOnILockBytes);
    DetourFunctionWithTrampoline((PBYTE)Real_StgCreatePropSetStg,
                                 (PBYTE)Mine_StgCreatePropSetStg);
    DetourFunctionWithTrampoline((PBYTE)Real_StgCreatePropStg,
                                 (PBYTE)Mine_StgCreatePropStg);
    DetourFunctionWithTrampoline((PBYTE)Real_StgCreateStorageEx,
                                 (PBYTE)Mine_StgCreateStorageEx);
    DetourFunctionWithTrampoline((PBYTE)Real_StgGetIFillLockBytesOnFile,
                                 (PBYTE)Mine_StgGetIFillLockBytesOnFile);
    DetourFunctionWithTrampoline((PBYTE)Real_StgGetIFillLockBytesOnILockBytes,
                                 (PBYTE)Mine_StgGetIFillLockBytesOnILockBytes);
    DetourFunctionWithTrampoline((PBYTE)Real_StgIsStorageFile,
                                 (PBYTE)Mine_StgIsStorageFile);
    DetourFunctionWithTrampoline((PBYTE)Real_StgIsStorageILockBytes,
                                 (PBYTE)Mine_StgIsStorageILockBytes);
    DetourFunctionWithTrampoline((PBYTE)Real_StgOpenAsyncDocfileOnIFillLockBytes,
                                 (PBYTE)Mine_StgOpenAsyncDocfileOnIFillLockBytes);
    DetourFunctionWithTrampoline((PBYTE)Real_StgOpenPropStg,
                                 (PBYTE)Mine_StgOpenPropStg);
    DetourFunctionWithTrampoline((PBYTE)Real_StgOpenStorage,
                                 (PBYTE)Mine_StgOpenStorage);
    DetourFunctionWithTrampoline((PBYTE)Real_StgOpenStorageEx,
                                 (PBYTE)Mine_StgOpenStorageEx);
    DetourFunctionWithTrampoline((PBYTE)Real_StgOpenStorageOnILockBytes,
                                 (PBYTE)Mine_StgOpenStorageOnILockBytes);
    DetourFunctionWithTrampoline((PBYTE)Real_StgSetTimes,
                                 (PBYTE)Mine_StgSetTimes);
    DetourFunctionWithTrampoline((PBYTE)Real_StretchBlt,
                                 (PBYTE)Mine_StretchBlt);
    DetourFunctionWithTrampoline((PBYTE)Real_StretchDIBits,
                                 (PBYTE)Mine_StretchDIBits);
    DetourFunctionWithTrampoline((PBYTE)Real_StringFromCLSID,
                                 (PBYTE)Mine_StringFromCLSID);
    DetourFunctionWithTrampoline((PBYTE)Real_StringFromGUID2,
                                 (PBYTE)Mine_StringFromGUID2);
    DetourFunctionWithTrampoline((PBYTE)Real_StringFromIID,
                                 (PBYTE)Mine_StringFromIID);
    DetourFunctionWithTrampoline((PBYTE)Real_StrokeAndFillPath,
                                 (PBYTE)Mine_StrokeAndFillPath);
    DetourFunctionWithTrampoline((PBYTE)Real_StrokePath,
                                 (PBYTE)Mine_StrokePath);
    DetourFunctionWithTrampoline((PBYTE)Real_SubtractRect,
                                 (PBYTE)Mine_SubtractRect);
    DetourFunctionWithTrampoline((PBYTE)Real_SuspendThread,
                                 (PBYTE)Mine_SuspendThread);
    DetourFunctionWithTrampoline((PBYTE)Real_SwapBuffers,
                                 (PBYTE)Mine_SwapBuffers);
    DetourFunctionWithTrampoline((PBYTE)Real_SwapMouseButton,
                                 (PBYTE)Mine_SwapMouseButton);
    DetourFunctionWithTrampoline((PBYTE)Real_SwitchDesktop,
                                 (PBYTE)Mine_SwitchDesktop);
    DetourFunctionWithTrampoline((PBYTE)Real_SwitchToFiber,
                                 (PBYTE)Mine_SwitchToFiber);
    DetourFunctionWithTrampoline((PBYTE)Real_SwitchToThread,
                                 (PBYTE)Mine_SwitchToThread);
    DetourFunctionWithTrampoline((PBYTE)Real_SystemParametersInfoA,
                                 (PBYTE)Mine_SystemParametersInfoA);
    DetourFunctionWithTrampoline((PBYTE)Real_SystemParametersInfoW,
                                 (PBYTE)Mine_SystemParametersInfoW);
    DetourFunctionWithTrampoline((PBYTE)Real_SystemTimeToFileTime,
                                 (PBYTE)Mine_SystemTimeToFileTime);
    DetourFunctionWithTrampoline((PBYTE)Real_SystemTimeToTzSpecificLocalTime,
                                 (PBYTE)Mine_SystemTimeToTzSpecificLocalTime);
    DetourFunctionWithTrampoline((PBYTE)Real_TabbedTextOutA,
                                 (PBYTE)Mine_TabbedTextOutA);
    DetourFunctionWithTrampoline((PBYTE)Real_TabbedTextOutW,
                                 (PBYTE)Mine_TabbedTextOutW);
    DetourFunctionWithTrampoline((PBYTE)Real_TerminateProcess,
                                 (PBYTE)Mine_TerminateProcess);
    DetourFunctionWithTrampoline((PBYTE)Real_TerminateThread,
                                 (PBYTE)Mine_TerminateThread);
    DetourFunctionWithTrampoline((PBYTE)Real_TextOutA,
                                 (PBYTE)Mine_TextOutA);
    DetourFunctionWithTrampoline((PBYTE)Real_TextOutW,
                                 (PBYTE)Mine_TextOutW);
    DetourFunctionWithTrampoline((PBYTE)Real_TileWindows,
                                 (PBYTE)Mine_TileWindows);
    DetourFunctionWithTrampoline((PBYTE)Real_ToAscii,
                                 (PBYTE)Mine_ToAscii);
    DetourFunctionWithTrampoline((PBYTE)Real_ToAsciiEx,
                                 (PBYTE)Mine_ToAsciiEx);
    DetourFunctionWithTrampoline((PBYTE)Real_ToUnicode,
                                 (PBYTE)Mine_ToUnicode);
    DetourFunctionWithTrampoline((PBYTE)Real_ToUnicodeEx,
                                 (PBYTE)Mine_ToUnicodeEx);
    DetourFunctionWithTrampoline((PBYTE)Real_TrackMouseEvent,
                                 (PBYTE)Mine_TrackMouseEvent);
    DetourFunctionWithTrampoline((PBYTE)Real_TrackPopupMenu,
                                 (PBYTE)Mine_TrackPopupMenu);
    DetourFunctionWithTrampoline((PBYTE)Real_TrackPopupMenuEx,
                                 (PBYTE)Mine_TrackPopupMenuEx);
    DetourFunctionWithTrampoline((PBYTE)Real_TransactNamedPipe,
                                 (PBYTE)Mine_TransactNamedPipe);
    DetourFunctionWithTrampoline((PBYTE)Real_TranslateAcceleratorA,
                                 (PBYTE)Mine_TranslateAcceleratorA);
    DetourFunctionWithTrampoline((PBYTE)Real_TranslateAcceleratorW,
                                 (PBYTE)Mine_TranslateAcceleratorW);
    DetourFunctionWithTrampoline((PBYTE)Real_TranslateCharsetInfo,
                                 (PBYTE)Mine_TranslateCharsetInfo);
    DetourFunctionWithTrampoline((PBYTE)Real_TranslateMDISysAccel,
                                 (PBYTE)Mine_TranslateMDISysAccel);
    DetourFunctionWithTrampoline((PBYTE)Real_TranslateMessage,
                                 (PBYTE)Mine_TranslateMessage);
    DetourFunctionWithTrampoline((PBYTE)Real_TransmitCommChar,
                                 (PBYTE)Mine_TransmitCommChar);
    DetourFunctionWithTrampoline((PBYTE)Real_TryEnterCriticalSection,
                                 (PBYTE)Mine_TryEnterCriticalSection);
    DetourFunctionWithTrampoline((PBYTE)Real_UnhookWindowsHook,
                                 (PBYTE)Mine_UnhookWindowsHook);
    DetourFunctionWithTrampoline((PBYTE)Real_UnhookWindowsHookEx,
                                 (PBYTE)Mine_UnhookWindowsHookEx);
    DetourFunctionWithTrampoline((PBYTE)Real_UnionRect,
                                 (PBYTE)Mine_UnionRect);
    DetourFunctionWithTrampoline((PBYTE)Real_UnloadKeyboardLayout,
                                 (PBYTE)Mine_UnloadKeyboardLayout);
    DetourFunctionWithTrampoline((PBYTE)Real_UnlockFile,
                                 (PBYTE)Mine_UnlockFile);
    DetourFunctionWithTrampoline((PBYTE)Real_UnlockFileEx,
                                 (PBYTE)Mine_UnlockFileEx);
    DetourFunctionWithTrampoline((PBYTE)Real_UnmapViewOfFile,
                                 (PBYTE)Mine_UnmapViewOfFile);
    DetourFunctionWithTrampoline((PBYTE)Real_UnpackDDElParam,
                                 (PBYTE)Mine_UnpackDDElParam);
    DetourFunctionWithTrampoline((PBYTE)Real_UnrealizeObject,
                                 (PBYTE)Mine_UnrealizeObject);
    DetourFunctionWithTrampoline((PBYTE)Real_UnregisterClassA,
                                 (PBYTE)Mine_UnregisterClassA);
    DetourFunctionWithTrampoline((PBYTE)Real_UnregisterClassW,
                                 (PBYTE)Mine_UnregisterClassW);
    DetourFunctionWithTrampoline((PBYTE)Real_UnregisterHotKey,
                                 (PBYTE)Mine_UnregisterHotKey);
    DetourFunctionWithTrampoline((PBYTE)Real_UpdateColors,
                                 (PBYTE)Mine_UpdateColors);
    DetourFunctionWithTrampoline((PBYTE)Real_UpdateICMRegKeyA,
                                 (PBYTE)Mine_UpdateICMRegKeyA);
    DetourFunctionWithTrampoline((PBYTE)Real_UpdateICMRegKeyW,
                                 (PBYTE)Mine_UpdateICMRegKeyW);
    DetourFunctionWithTrampoline((PBYTE)Real_UpdateResourceA,
                                 (PBYTE)Mine_UpdateResourceA);
    DetourFunctionWithTrampoline((PBYTE)Real_UpdateResourceW,
                                 (PBYTE)Mine_UpdateResourceW);
    DetourFunctionWithTrampoline((PBYTE)Real_UpdateWindow,
                                 (PBYTE)Mine_UpdateWindow);
    DetourFunctionWithTrampoline((PBYTE)Real_ValidateRect,
                                 (PBYTE)Mine_ValidateRect);
    DetourFunctionWithTrampoline((PBYTE)Real_ValidateRgn,
                                 (PBYTE)Mine_ValidateRgn);
    DetourFunctionWithTrampoline((PBYTE)Real_VerLanguageNameA,
                                 (PBYTE)Mine_VerLanguageNameA);
    DetourFunctionWithTrampoline((PBYTE)Real_VerLanguageNameW,
                                 (PBYTE)Mine_VerLanguageNameW);
    DetourFunctionWithTrampoline((PBYTE)Real_VirtualAllocEx,
                                 (PBYTE)Mine_VirtualAllocEx);
    DetourFunctionWithTrampoline((PBYTE)Real_VirtualFreeEx,
                                 (PBYTE)Mine_VirtualFreeEx);
    DetourFunctionWithTrampoline((PBYTE)Real_VirtualProtectEx,
                                 (PBYTE)Mine_VirtualProtectEx);
    DetourFunctionWithTrampoline((PBYTE)Real_VirtualQueryEx,
                                 (PBYTE)Mine_VirtualQueryEx);
    DetourFunctionWithTrampoline((PBYTE)Real_VkKeyScanA,
                                 (PBYTE)Mine_VkKeyScanA);
    DetourFunctionWithTrampoline((PBYTE)Real_VkKeyScanExA,
                                 (PBYTE)Mine_VkKeyScanExA);
    DetourFunctionWithTrampoline((PBYTE)Real_VkKeyScanExW,
                                 (PBYTE)Mine_VkKeyScanExW);
    DetourFunctionWithTrampoline((PBYTE)Real_VkKeyScanW,
                                 (PBYTE)Mine_VkKeyScanW);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAAccept,
                                 (PBYTE)Mine_WSAAccept);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAAddressToStringA,
                                 (PBYTE)Mine_WSAAddressToStringA);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAAddressToStringW,
                                 (PBYTE)Mine_WSAAddressToStringW);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAAsyncGetHostByAddr,
                                 (PBYTE)Mine_WSAAsyncGetHostByAddr);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAAsyncGetHostByName,
                                 (PBYTE)Mine_WSAAsyncGetHostByName);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAAsyncGetProtoByName,
                                 (PBYTE)Mine_WSAAsyncGetProtoByName);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAAsyncGetProtoByNumber,
                                 (PBYTE)Mine_WSAAsyncGetProtoByNumber);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAAsyncGetServByName,
                                 (PBYTE)Mine_WSAAsyncGetServByName);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAAsyncGetServByPort,
                                 (PBYTE)Mine_WSAAsyncGetServByPort);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAAsyncSelect,
                                 (PBYTE)Mine_WSAAsyncSelect);
    DetourFunctionWithTrampoline((PBYTE)Real_WSACancelAsyncRequest,
                                 (PBYTE)Mine_WSACancelAsyncRequest);
    DetourFunctionWithTrampoline((PBYTE)Real_WSACancelBlockingCall,
                                 (PBYTE)Mine_WSACancelBlockingCall);
    DetourFunctionWithTrampoline((PBYTE)Real_WSACleanup,
                                 (PBYTE)Mine_WSACleanup);
    DetourFunctionWithTrampoline((PBYTE)Real_WSACloseEvent,
                                 (PBYTE)Mine_WSACloseEvent);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAConnect,
                                 (PBYTE)Mine_WSAConnect);
    DetourFunctionWithTrampoline((PBYTE)Real_WSACreateEvent,
                                 (PBYTE)Mine_WSACreateEvent);
    DetourFunctionWithTrampoline((PBYTE)Real_WSADuplicateSocketA,
                                 (PBYTE)Mine_WSADuplicateSocketA);
    DetourFunctionWithTrampoline((PBYTE)Real_WSADuplicateSocketW,
                                 (PBYTE)Mine_WSADuplicateSocketW);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAEnumNameSpaceProvidersA,
                                 (PBYTE)Mine_WSAEnumNameSpaceProvidersA);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAEnumNameSpaceProvidersW,
                                 (PBYTE)Mine_WSAEnumNameSpaceProvidersW);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAEnumNetworkEvents,
                                 (PBYTE)Mine_WSAEnumNetworkEvents);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAEnumProtocolsA,
                                 (PBYTE)Mine_WSAEnumProtocolsA);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAEnumProtocolsW,
                                 (PBYTE)Mine_WSAEnumProtocolsW);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAEventSelect,
                                 (PBYTE)Mine_WSAEventSelect);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAGetOverlappedResult,
                                 (PBYTE)Mine_WSAGetOverlappedResult);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAGetQOSByName,
                                 (PBYTE)Mine_WSAGetQOSByName);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAGetServiceClassInfoA,
                                 (PBYTE)Mine_WSAGetServiceClassInfoA);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAGetServiceClassInfoW,
                                 (PBYTE)Mine_WSAGetServiceClassInfoW);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAGetServiceClassNameByClassIdA,
                                 (PBYTE)Mine_WSAGetServiceClassNameByClassIdA);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAGetServiceClassNameByClassIdW,
                                 (PBYTE)Mine_WSAGetServiceClassNameByClassIdW);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAHtonl,
                                 (PBYTE)Mine_WSAHtonl);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAHtons,
                                 (PBYTE)Mine_WSAHtons);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAInstallServiceClassA,
                                 (PBYTE)Mine_WSAInstallServiceClassA);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAInstallServiceClassW,
                                 (PBYTE)Mine_WSAInstallServiceClassW);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAIoctl,
                                 (PBYTE)Mine_WSAIoctl);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAIsBlocking,
                                 (PBYTE)Mine_WSAIsBlocking);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAJoinLeaf,
                                 (PBYTE)Mine_WSAJoinLeaf);
    DetourFunctionWithTrampoline((PBYTE)Real_WSALookupServiceBeginA,
                                 (PBYTE)Mine_WSALookupServiceBeginA);
    DetourFunctionWithTrampoline((PBYTE)Real_WSALookupServiceBeginW,
                                 (PBYTE)Mine_WSALookupServiceBeginW);
    DetourFunctionWithTrampoline((PBYTE)Real_WSALookupServiceEnd,
                                 (PBYTE)Mine_WSALookupServiceEnd);
    DetourFunctionWithTrampoline((PBYTE)Real_WSALookupServiceNextA,
                                 (PBYTE)Mine_WSALookupServiceNextA);
    DetourFunctionWithTrampoline((PBYTE)Real_WSALookupServiceNextW,
                                 (PBYTE)Mine_WSALookupServiceNextW);
    DetourFunctionWithTrampoline((PBYTE)Real_WSANtohl,
                                 (PBYTE)Mine_WSANtohl);
    DetourFunctionWithTrampoline((PBYTE)Real_WSANtohs,
                                 (PBYTE)Mine_WSANtohs);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAProviderConfigChange,
                                 (PBYTE)Mine_WSAProviderConfigChange);
    DetourFunctionWithTrampoline((PBYTE)Real_WSARecv,
                                 (PBYTE)Mine_WSARecv);
    DetourFunctionWithTrampoline((PBYTE)Real_WSARecvDisconnect,
                                 (PBYTE)Mine_WSARecvDisconnect);
    DetourFunctionWithTrampoline((PBYTE)Real_WSARecvFrom,
                                 (PBYTE)Mine_WSARecvFrom);
    DetourFunctionWithTrampoline((PBYTE)Real_WSARemoveServiceClass,
                                 (PBYTE)Mine_WSARemoveServiceClass);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAResetEvent,
                                 (PBYTE)Mine_WSAResetEvent);
    DetourFunctionWithTrampoline((PBYTE)Real_WSASend,
                                 (PBYTE)Mine_WSASend);
    DetourFunctionWithTrampoline((PBYTE)Real_WSASendDisconnect,
                                 (PBYTE)Mine_WSASendDisconnect);
    DetourFunctionWithTrampoline((PBYTE)Real_WSASendTo,
                                 (PBYTE)Mine_WSASendTo);
    DetourFunctionWithTrampoline((PBYTE)Real_WSASetBlockingHook,
                                 (PBYTE)Mine_WSASetBlockingHook);
    DetourFunctionWithTrampoline((PBYTE)Real_WSASetEvent,
                                 (PBYTE)Mine_WSASetEvent);
    DetourFunctionWithTrampoline((PBYTE)Real_WSASetServiceA,
                                 (PBYTE)Mine_WSASetServiceA);
    DetourFunctionWithTrampoline((PBYTE)Real_WSASetServiceW,
                                 (PBYTE)Mine_WSASetServiceW);
    DetourFunctionWithTrampoline((PBYTE)Real_WSASocketA,
                                 (PBYTE)Mine_WSASocketA);
    DetourFunctionWithTrampoline((PBYTE)Real_WSASocketW,
                                 (PBYTE)Mine_WSASocketW);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAStartup,
                                 (PBYTE)Mine_WSAStartup);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAStringToAddressA,
                                 (PBYTE)Mine_WSAStringToAddressA);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAStringToAddressW,
                                 (PBYTE)Mine_WSAStringToAddressW);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAUnhookBlockingHook,
                                 (PBYTE)Mine_WSAUnhookBlockingHook);
    DetourFunctionWithTrampoline((PBYTE)Real_WSAWaitForMultipleEvents,
                                 (PBYTE)Mine_WSAWaitForMultipleEvents);
    DetourFunctionWithTrampoline((PBYTE)Real_WaitCommEvent,
                                 (PBYTE)Mine_WaitCommEvent);
    DetourFunctionWithTrampoline((PBYTE)Real_WaitForDebugEvent,
                                 (PBYTE)Mine_WaitForDebugEvent);
    DetourFunctionWithTrampoline((PBYTE)Real_WaitForInputIdle,
                                 (PBYTE)Mine_WaitForInputIdle);
    DetourFunctionWithTrampoline((PBYTE)Real_WaitForMultipleObjects,
                                 (PBYTE)Mine_WaitForMultipleObjects);
    DetourFunctionWithTrampoline((PBYTE)Real_WaitForMultipleObjectsEx,
                                 (PBYTE)Mine_WaitForMultipleObjectsEx);
    DetourFunctionWithTrampoline((PBYTE)Real_WaitForSingleObject,
                                 (PBYTE)Mine_WaitForSingleObject);
    DetourFunctionWithTrampoline((PBYTE)Real_WaitForSingleObjectEx,
                                 (PBYTE)Mine_WaitForSingleObjectEx);
    DetourFunctionWithTrampoline((PBYTE)Real_WaitMessage,
                                 (PBYTE)Mine_WaitMessage);
    DetourFunctionWithTrampoline((PBYTE)Real_WaitNamedPipeA,
                                 (PBYTE)Mine_WaitNamedPipeA);
    DetourFunctionWithTrampoline((PBYTE)Real_WaitNamedPipeW,
                                 (PBYTE)Mine_WaitNamedPipeW);
    DetourFunctionWithTrampoline((PBYTE)Real_WidenPath,
                                 (PBYTE)Mine_WidenPath);
    DetourFunctionWithTrampoline((PBYTE)Real_WinExec,
                                 (PBYTE)Mine_WinExec);
    DetourFunctionWithTrampoline((PBYTE)Real_WinHelpA,
                                 (PBYTE)Mine_WinHelpA);
    DetourFunctionWithTrampoline((PBYTE)Real_WinHelpW,
                                 (PBYTE)Mine_WinHelpW);
    DetourFunctionWithTrampoline((PBYTE)Real_WindowFromDC,
                                 (PBYTE)Mine_WindowFromDC);
    DetourFunctionWithTrampoline((PBYTE)Real_WindowFromPoint,
                                 (PBYTE)Mine_WindowFromPoint);
    DetourFunctionWithTrampoline((PBYTE)Real_WriteClassStg,
                                 (PBYTE)Mine_WriteClassStg);
    DetourFunctionWithTrampoline((PBYTE)Real_WriteClassStm,
                                 (PBYTE)Mine_WriteClassStm);
    DetourFunctionWithTrampoline((PBYTE)Real_WriteConsoleA,
                                 (PBYTE)Mine_WriteConsoleA);
    DetourFunctionWithTrampoline((PBYTE)Real_WriteConsoleInputA,
                                 (PBYTE)Mine_WriteConsoleInputA);
    DetourFunctionWithTrampoline((PBYTE)Real_WriteConsoleInputW,
                                 (PBYTE)Mine_WriteConsoleInputW);
    DetourFunctionWithTrampoline((PBYTE)Real_WriteConsoleOutputA,
                                 (PBYTE)Mine_WriteConsoleOutputA);
    DetourFunctionWithTrampoline((PBYTE)Real_WriteConsoleOutputAttribute,
                                 (PBYTE)Mine_WriteConsoleOutputAttribute);
    DetourFunctionWithTrampoline((PBYTE)Real_WriteConsoleOutputCharacterA,
                                 (PBYTE)Mine_WriteConsoleOutputCharacterA);
    DetourFunctionWithTrampoline((PBYTE)Real_WriteConsoleOutputCharacterW,
                                 (PBYTE)Mine_WriteConsoleOutputCharacterW);
    DetourFunctionWithTrampoline((PBYTE)Real_WriteConsoleOutputW,
                                 (PBYTE)Mine_WriteConsoleOutputW);
    DetourFunctionWithTrampoline((PBYTE)Real_WriteConsoleW,
                                 (PBYTE)Mine_WriteConsoleW);
    DetourFunctionWithTrampoline((PBYTE)Real_WriteFile,
                                 (PBYTE)Mine_WriteFile);
    DetourFunctionWithTrampoline((PBYTE)Real_WriteFileEx,
                                 (PBYTE)Mine_WriteFileEx);
    DetourFunctionWithTrampoline((PBYTE)Real_WriteFmtUserTypeStg,
                                 (PBYTE)Mine_WriteFmtUserTypeStg);
    DetourFunctionWithTrampoline((PBYTE)Real_WritePrivateProfileSectionA,
                                 (PBYTE)Mine_WritePrivateProfileSectionA);
    DetourFunctionWithTrampoline((PBYTE)Real_WritePrivateProfileSectionW,
                                 (PBYTE)Mine_WritePrivateProfileSectionW);
    DetourFunctionWithTrampoline((PBYTE)Real_WritePrivateProfileStringA,
                                 (PBYTE)Mine_WritePrivateProfileStringA);
    DetourFunctionWithTrampoline((PBYTE)Real_WritePrivateProfileStringW,
                                 (PBYTE)Mine_WritePrivateProfileStringW);
    DetourFunctionWithTrampoline((PBYTE)Real_WritePrivateProfileStructA,
                                 (PBYTE)Mine_WritePrivateProfileStructA);
    DetourFunctionWithTrampoline((PBYTE)Real_WritePrivateProfileStructW,
                                 (PBYTE)Mine_WritePrivateProfileStructW);
    DetourFunctionWithTrampoline((PBYTE)Real_WriteProcessMemory,
                                 (PBYTE)Mine_WriteProcessMemory);
    DetourFunctionWithTrampoline((PBYTE)Real_WriteProfileSectionA,
                                 (PBYTE)Mine_WriteProfileSectionA);
    DetourFunctionWithTrampoline((PBYTE)Real_WriteProfileSectionW,
                                 (PBYTE)Mine_WriteProfileSectionW);
    DetourFunctionWithTrampoline((PBYTE)Real_WriteProfileStringA,
                                 (PBYTE)Mine_WriteProfileStringA);
    DetourFunctionWithTrampoline((PBYTE)Real_WriteProfileStringW,
                                 (PBYTE)Mine_WriteProfileStringW);
    DetourFunctionWithTrampoline((PBYTE)Real_WriteTapemark,
                                 (PBYTE)Mine_WriteTapemark);
    DetourFunctionWithTrampoline((PBYTE)Real___WSAFDIsSet,
                                 (PBYTE)Mine___WSAFDIsSet);
    DetourFunctionWithTrampoline((PBYTE)Real__hread,
                                 (PBYTE)Mine__hread);
    DetourFunctionWithTrampoline((PBYTE)Real__hwrite,
                                 (PBYTE)Mine__hwrite);
    DetourFunctionWithTrampoline((PBYTE)Real__lclose,
                                 (PBYTE)Mine__lclose);
    DetourFunctionWithTrampoline((PBYTE)Real__lcreat,
                                 (PBYTE)Mine__lcreat);
    DetourFunctionWithTrampoline((PBYTE)Real__llseek,
                                 (PBYTE)Mine__llseek);
    DetourFunctionWithTrampoline((PBYTE)Real__lopen,
                                 (PBYTE)Mine__lopen);
    DetourFunctionWithTrampoline((PBYTE)Real__lread,
                                 (PBYTE)Mine__lread);
    DetourFunctionWithTrampoline((PBYTE)Real__lwrite,
                                 (PBYTE)Mine__lwrite);
    DetourFunctionWithTrampoline((PBYTE)Real_accept,
                                 (PBYTE)Mine_accept);
    DetourFunctionWithTrampoline((PBYTE)Real_bind,
                                 (PBYTE)Mine_bind);
    DetourFunctionWithTrampoline((PBYTE)Real_closesocket,
                                 (PBYTE)Mine_closesocket);
    DetourFunctionWithTrampoline((PBYTE)Real_connect,
                                 (PBYTE)Mine_connect);
    DetourFunctionWithTrampoline((PBYTE)Real_gethostbyaddr,
                                 (PBYTE)Mine_gethostbyaddr);
    DetourFunctionWithTrampoline((PBYTE)Real_gethostbyname,
                                 (PBYTE)Mine_gethostbyname);
    DetourFunctionWithTrampoline((PBYTE)Real_gethostname,
                                 (PBYTE)Mine_gethostname);
    DetourFunctionWithTrampoline((PBYTE)Real_getpeername,
                                 (PBYTE)Mine_getpeername);
    DetourFunctionWithTrampoline((PBYTE)Real_getprotobyname,
                                 (PBYTE)Mine_getprotobyname);
    DetourFunctionWithTrampoline((PBYTE)Real_getprotobynumber,
                                 (PBYTE)Mine_getprotobynumber);
    DetourFunctionWithTrampoline((PBYTE)Real_getservbyname,
                                 (PBYTE)Mine_getservbyname);
    DetourFunctionWithTrampoline((PBYTE)Real_getservbyport,
                                 (PBYTE)Mine_getservbyport);
    DetourFunctionWithTrampoline((PBYTE)Real_getsockname,
                                 (PBYTE)Mine_getsockname);
    DetourFunctionWithTrampoline((PBYTE)Real_getsockopt,
                                 (PBYTE)Mine_getsockopt);
    DetourFunctionWithTrampoline((PBYTE)Real_htonl,
                                 (PBYTE)Mine_htonl);
    DetourFunctionWithTrampoline((PBYTE)Real_htons,
                                 (PBYTE)Mine_htons);
    DetourFunctionWithTrampoline((PBYTE)Real_inet_addr,
                                 (PBYTE)Mine_inet_addr);
    DetourFunctionWithTrampoline((PBYTE)Real_inet_ntoa,
                                 (PBYTE)Mine_inet_ntoa);
    DetourFunctionWithTrampoline((PBYTE)Real_ioctlsocket,
                                 (PBYTE)Mine_ioctlsocket);
    DetourFunctionWithTrampoline((PBYTE)Real_keybd_event,
                                 (PBYTE)Mine_keybd_event);
    DetourFunctionWithTrampoline((PBYTE)Real_listen,
                                 (PBYTE)Mine_listen);
    DetourFunctionWithTrampoline((PBYTE)Real_lstrcatA,
                                 (PBYTE)Mine_lstrcatA);
    DetourFunctionWithTrampoline((PBYTE)Real_lstrcatW,
                                 (PBYTE)Mine_lstrcatW);
    DetourFunctionWithTrampoline((PBYTE)Real_lstrcmpA,
                                 (PBYTE)Mine_lstrcmpA);
    DetourFunctionWithTrampoline((PBYTE)Real_lstrcmpW,
                                 (PBYTE)Mine_lstrcmpW);
    DetourFunctionWithTrampoline((PBYTE)Real_lstrcmpiA,
                                 (PBYTE)Mine_lstrcmpiA);
    DetourFunctionWithTrampoline((PBYTE)Real_lstrcmpiW,
                                 (PBYTE)Mine_lstrcmpiW);
    DetourFunctionWithTrampoline((PBYTE)Real_lstrcpyA,
                                 (PBYTE)Mine_lstrcpyA);
    DetourFunctionWithTrampoline((PBYTE)Real_lstrcpyW,
                                 (PBYTE)Mine_lstrcpyW);
    DetourFunctionWithTrampoline((PBYTE)Real_lstrcpynA,
                                 (PBYTE)Mine_lstrcpynA);
    DetourFunctionWithTrampoline((PBYTE)Real_lstrcpynW,
                                 (PBYTE)Mine_lstrcpynW);
    DetourFunctionWithTrampoline((PBYTE)Real_lstrlenA,
                                 (PBYTE)Mine_lstrlenA);
    DetourFunctionWithTrampoline((PBYTE)Real_lstrlenW,
                                 (PBYTE)Mine_lstrlenW);
    DetourFunctionWithTrampoline((PBYTE)Real_mouse_event,
                                 (PBYTE)Mine_mouse_event);
    DetourFunctionWithTrampoline((PBYTE)Real_ntohl,
                                 (PBYTE)Mine_ntohl);
    DetourFunctionWithTrampoline((PBYTE)Real_ntohs,
                                 (PBYTE)Mine_ntohs);
    DetourFunctionWithTrampoline((PBYTE)Real_recv,
                                 (PBYTE)Mine_recv);
    DetourFunctionWithTrampoline((PBYTE)Real_recvfrom,
                                 (PBYTE)Mine_recvfrom);
    DetourFunctionWithTrampoline((PBYTE)Real_select,
                                 (PBYTE)Mine_select);
    DetourFunctionWithTrampoline((PBYTE)Real_send,
                                 (PBYTE)Mine_send);
    DetourFunctionWithTrampoline((PBYTE)Real_sendto,
                                 (PBYTE)Mine_sendto);
    DetourFunctionWithTrampoline((PBYTE)Real_setsockopt,
                                 (PBYTE)Mine_setsockopt);
    DetourFunctionWithTrampoline((PBYTE)Real_shutdown,
                                 (PBYTE)Mine_shutdown);
    DetourFunctionWithTrampoline((PBYTE)Real_socket,
                                 (PBYTE)Mine_socket);
}

//
///////////////////////////////////////////////////////////////// End of File.
